import { Client } from "@1st-flock/donations-embed-node";

const client = new Client({ apiKey: process.env.FLOCK_SECRET_KEY! });

async function syncRecentDonations(sinceIso: string): Promise<void> {
  let cursor: string | undefined;
  do {
    const page = await client.listDonations({ cursor, limit: 200 });
    for (const donation of page.donations) {
      if (donation.created_at < sinceIso) {
        return; // Older than the window — done.
      }
      await upsertDonation(donation);
    }
    cursor = page.next_cursor ?? undefined;
  } while (cursor);
}

setInterval(() => {
  const since = new Date(Date.now() - 60 * 60 * 1000).toISOString();
  syncRecentDonations(since);
}, 60_000);

import asyncio
from datetime import datetime, timedelta, timezone
from donations_embed import Client

async def sync_recent_donations(since: datetime) -> None:
    async with Client(api_key=os.environ["FLOCK_SECRET_KEY"]) as client:
        cursor: str | None = None
        while True:
            page = await client.list_donations(cursor=cursor, limit=200)
            for donation in page.donations:
                if donation.created_at < since:
                    return  # Older than the window — done.
                await upsert_donation(donation)
            if page.next_cursor is None:
                return
            cursor = page.next_cursor

async def main() -> None:
    while True:
        since = datetime.now(timezone.utc) - timedelta(hours=1)
        await sync_recent_donations(since)
        await asyncio.sleep(60)

asyncio.run(main())

package main

import (
    "context"
    "log"
    "os"
    "time"

    donationsembed "gitlab.com/1st-flock/donations/go/donations-embed"
)

func syncRecentDonations(ctx context.Context, c *donationsembed.Client, since time.Time) error {
    var cursor string
    for {
        page, err := c.ListDonations(ctx, &donationsembed.ListDonationsParams{
            Cursor: cursor,
            Limit:  200,
        })
        if err != nil {
            return err
        }
        for _, d := range page.Donations {
            if d.CreatedAt.Before(since) {
                return nil
            }
            if err := upsertDonation(ctx, d); err != nil {
                return err
            }
        }
        if page.NextCursor == nil {
            return nil
        }
        cursor = *page.NextCursor
    }
}

func main() {
    c, err := donationsembed.New(os.Getenv("FLOCK_SECRET_KEY"))
    if err != nil {
        log.Fatal(err)
    }
    ticker := time.NewTicker(time.Minute)
    defer ticker.Stop()
    for range ticker.C {
        since := time.Now().UTC().Add(-time.Hour)
        if err := syncRecentDonations(context.Background(), c, since); err != nil {
            log.Printf("sync error: %v", err)
        }
    }
}

import { Client, idempotencyKey, RateLimitError } from "@1st-flock/donations-embed-node";

const client = new Client({ apiKey: process.env.FLOCK_SECRET_KEY! });

async function refundWithRetry(donationId: string, amountCents: number) {
  const key = idempotencyKey("refund");
  for (let attempt = 1; attempt <= 5; attempt++) {
    try {
      return await client.refundDonation(
        donationId,
        { amountCents },
        { idempotencyKey: key },
      );
    } catch (err) {
      if (err instanceof RateLimitError) {
        await sleep((err.retryAfterSeconds ?? 1) * 1000);
        continue;
      }
      throw err;
    }
  }
  throw new Error("retry budget exhausted");
}

import asyncio
from donations_embed import Client, RateLimitError, idempotency_key

async def refund_with_retry(donation_id: str, amount_cents: int):
    key = idempotency_key("refund")
    async with Client(api_key=os.environ["FLOCK_SECRET_KEY"]) as client:
        for attempt in range(5):
            try:
                return await client.refund_donation(
                    donation_id,
                    amount_cents=amount_cents,
                    idempotency_key=key,
                )
            except RateLimitError as exc:
                await asyncio.sleep(exc.retry_after or 1.0)
                continue
        raise RuntimeError("retry budget exhausted")

package main

import (
    "context"
    "errors"
    "fmt"
    "time"

    donationsembed "gitlab.com/1st-flock/donations/go/donations-embed"
)

func refundWithRetry(ctx context.Context, c *donationsembed.Client, donationID string, amountCents int64) (*donationsembed.RefundResponse, error) {
    key := donationsembed.IdempotencyKey("refund")
    for attempt := 0; attempt < 5; attempt++ {
        resp, err := c.RefundDonation(ctx, donationID,
            &donationsembed.RefundParams{AmountCents: &amountCents},
            donationsembed.WithIdempotencyKey(key),
        )
        if err == nil {
            return resp, nil
        }
        var rl *donationsembed.RateLimitError
        if errors.As(err, &rl) {
            time.Sleep(rl.RetryAfter)
            continue
        }
        return nil, err
    }
    return nil, fmt.Errorf("retry budget exhausted")
}