Signed local delivery with Edge and .NET

{
  "workspace": {
    "environment": "${QUEUEY_WORKSPACE_ENVIRONMENT}",
    "ingress": { "authMode": "SignedRequest", "signedRequest": { "template": "queuey" } }
  },
  "queues": {
    "orders": {
      "delivery": {
        "url": "/webhooks/queuey",
        "kind": "localForward",
        "signing": { "enabled": true, "templateKey": "queuey", "credentialRef": "shop-delivery" }
      }
    }
  },
  "profiles": {
    "dev": { "variables": { "QUEUEY_WORKSPACE_ENVIRONMENT": "dev" } }
  }
}

queuey login --profile dev --json        # show the person the link; then: queuey login --profile dev --wait
queuey whoami --profile dev              # the dev workspace's id (ten_…), for QUEUEY_TENANT below

# Both secrets go straight into .env (git-ignored), the same value as in Queuey, never shown:
queuey keys mint --profile dev --write .env                            # the sender: QUEUEY_SIGNING_KEY_ID, QUEUEY_SIGNING_SECRET
queuey credentials generate shop-delivery --profile dev --write .env   # the receiver: QUEUEY_DELIVERY_SECRET

queuey plan --profile dev                # what apply would change
queuey apply --profile dev

queuey listen --queue orders --forward-to http://localhost:5080 --profile dev

queuey replay evt_… --queue que_…                           # one event to your listener, read-only
queuey replay --queue orders --status dlq --profile dev       # the DLQ, delivered again

using System.Collections.Concurrent;
using Queuey.Client;
using Queuey.Edge;

var builder = WebApplication.CreateBuilder(args);

// The sender. Edge commits each event to a local spool before PublishAsync returns,
// and signs it with the workspace's key when it sends it.
builder.Services.AddQueueyEdge(o =>
{
    o.UseEnvironmentVariables();   // QUEUEY_SIGNING_KEY_ID + _SECRET: the environment, or .env in Development
                                   // QUEUEY_TENANT: the environment only (launchSettings.json below)
    // Durable: not under bin/, which a rebuild or dotnet clean can empty. Git-ignore .queuey/.
    o.Storage.Path = Path.Combine(builder.Environment.ContentRootPath, ".queuey", "spool.db");
});

// The receiver. QUEUEY_DELIVERY_SECRET: the environment, or .env in Development.
var seenNonces = new ConcurrentDictionary<string, byte>();   // keep them a little over five minutes in a real app
var verifier = QueueyDeliveryVerifier.FromEnvironment(new QueueyDeliveryVerifierOptions
{
    NonceAlreadySeen = nonce => !seenNonces.TryAdd(nonce, 0),
});
var handled = new ConcurrentDictionary<string, byte>();      // your database in a real app

var app = builder.Build();

app.MapPost("/orders", async (Order order, IQueueyPublisher queuey) =>
{
    await queuey.PublishAsync("orders", order, new PublishOptions
    {
        EventType = "order.created",
        IdempotencyKey = order.Id,   // a retried request is stored once
    });
    return Results.Accepted();
});

app.MapPost("/webhooks/queuey", async (HttpRequest request) =>
{
    using var buffer = new MemoryStream();
    await request.Body.CopyToAsync(buffer);   // the raw bytes, before anything deserializes them
    var body = buffer.ToArray();

    var result = verifier.Verify(
        request.Method,
        new Uri($"{request.Scheme}://{request.Host}{request.Path}{request.QueryString}"),
        name => request.Headers[name],
        body);
    if (!result.IsValid) return Results.Unauthorized();

    // A redelivery of an event already handled: answer 200, do nothing.
    if (result.EventId is { } eventId && !handled.TryAdd(eventId, 0)) return Results.Ok();

    // … handle the order
    return Results.Ok();
});

app.Run();

record Order(string Id, decimal Total);

{
  "profiles": {
    "shop": {
      "commandName": "Project",
      "applicationUrl": "http://localhost:5080",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "QUEUEY_TENANT": "ten_…"
      }
    }
  }
}

.env
.queuey/

// Queuey.Client instead of Edge: no spool, the publish goes straight to the ingress.
builder.Services.AddQueueyClient(o => o.UseEnvironmentVariables());

app.MapPost("/orders", async (Order order, QueueyClient queuey) =>
{
    await queuey.Ingress.PublishAsync("orders", order, new PublishOptions { EventType = "order.created", IdempotencyKey = order.Id });
    return Results.Accepted();
});