Autoriser les canaux

import { BirdRealtime } from "@messagebird/realtime";

const bird = new BirdRealtime({
  appKey: "your-app-key",
  region: "us1",
  authEndpoint: "/bird/auth",
});

const room = bird.subscribe("presence-room-1");

import BirdRealtime

let bird = BirdRealtime(options: .init(
    appKey: "your-app-key",
    region: "us1",
    authEndpoint: URL(string: "https://your-backend.example.com/bird/auth")
))

let room = bird.subscribe("presence-room-1")

import com.bird.realtime.BirdRealtime
import com.bird.realtime.BirdRealtimeOptions

val bird = BirdRealtime(
    BirdRealtimeOptions(
        appKey = "your-app-key",
        region = "us1",
        authEndpoint = "https://your-backend.example.com/bird/auth",
    )
)

val room = bird.subscribe("presence-room-1")

app.post("/bird/auth", async (req, res) => {
  const { connection_id, channel_name } = req.body;

  // Your own authorization decision goes here.
  const user = getUserFromSession(req);
  if (!user || !mayJoin(user, channel_name)) return res.sendStatus(403);

  const memberData = channel_name.startsWith("presence-")
    ? JSON.stringify({ member_id: user.id, member_info: { name: user.name } })
    : undefined;

  res.json(
    await bird.realtime.authorizeChannel({
      connectionId: connection_id,
      channelName: channel_name,
      memberData,
    }),
  );
});

import json

@app.post("/bird/auth")
def bird_auth():
    body = request.get_json()
    channel_name = body["channel_name"]

    # Your own authorization decision goes here.
    user = get_user_from_session()
    if user is None or not may_join(user, channel_name):
        abort(403)

    member_data = None
    if channel_name.startswith("presence-"):
        member_data = json.dumps({"member_id": user.id, "member_info": {"name": user.name}})

    return client.realtime.authorize_channel(
        connection_id=body["connection_id"],
        channel_name=channel_name,
        member_data=member_data,
    )

func birdAuth(w http.ResponseWriter, r *http.Request) {
	var body struct {
		ConnectionID string `json:"connection_id"`
		ChannelName  string `json:"channel_name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		http.Error(w, "bad request", http.StatusBadRequest)
		return
	}

	// Your own authorization decision goes here.
	user, ok := userFromSession(r)
	if !ok || !mayJoin(user, body.ChannelName) {
		http.Error(w, "forbidden", http.StatusForbidden)
		return
	}

	params := bird.RealtimeChannelAuthorizationParams{
		ConnectionID: body.ConnectionID,
		ChannelName:  body.ChannelName,
	}
	if strings.HasPrefix(body.ChannelName, "presence-") {
		memberData, _ := json.Marshal(map[string]any{
			"member_id":   user.ID,
			"member_info": map[string]string{"name": user.Name},
		})
		params.MemberData = string(memberData)
	}

	auth, err := client.Realtime.AuthorizeChannel(params)
	if err != nil {
		http.Error(w, "authorization failed", http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(auth)
}

function birdAuth(string $connectionId, string $channelName, User $user): array
{
    // Your own authorization decision goes here.
    if (!mayJoin($user, $channelName)) {
        http_response_code(403);
        exit;
    }

    $memberData = null;
    if (str_starts_with($channelName, 'presence-')) {
        $memberData = json_encode(['member_id' => $user->id, 'member_info' => ['name' => $user->name]]);
    }

    return $bird->realtime->authorizeChannel($connectionId, $channelName, $memberData);
}