Realtime

// xano/realtime/chat.ts
import { realtimeServer } from "@xano/sdk";

export const chat = realtimeServer({ name: "chat", enabled: true });

// xano/realtime/chat.ts
import { realtimeChannel, input } from "@xano/sdk";

export const room = realtimeChannel({
  name: "rooms/{room_id}", // input types the {room_id} path param
  server: chat,
  input: { room_id: input.int() },
  publish: { who: "authenticated" }, // the default is "nobody"
  presence: true,
  conversation: { enabled: true, limit: 50 }, // replay the last 50 messages on join
  delivery: { perRecipient: true }, // lets a deliver trigger run (below)
});

// xano/realtime/chat.ts
import { realtimeMessage, input, inp } from "@xano/sdk";

export const send = realtimeMessage({
  name: "send", // input types the message payload
  channel: room,
  input: { body: input.text({ required: true }) },
  deliverTo: "channel", // or "sender" for request/response, "others" to skip the sender
  response: { room_id: inp("room_id"), body: inp("body") }, // what every member receives
});

// xano/realtime/push.ts
import { apiGroup, query, input, inp, obj, s, c } from "@xano/sdk";
import { chat, room } from "./chat.js";

export const admin = apiGroup({ name: "admin", canonical: "admin" });

export const announce = query({
  name: "announce",
  verb: "POST",
  apiGroup: admin,
  input: { body: input.text({ required: true }) },
  stack: [
    s.realtime.publish({
      server: chat,
      channel: room.getChannel({ room_id: 1 }), // a filled-in path, never the template
      data: obj({ body: inp("body") }),
    }),
  ],
  response: { sent: c.bool(true) },
});

// xano/realtime/gates.ts
import { realtimeServerTrigger, s, c } from "@xano/sdk";

export const onConnect = realtimeServerTrigger({
  name: "on_chat_connect",
  realtimeServer: chat,
  actions: { connect: true, disconnect: true },
  stack: (t) => [s.debug.log({ value: t.action })],
  // connect admits only on a truthy response; disconnect ignores it.
  response: () => ({ allowed: c.bool(true) }),
});

// xano/realtime/gates.ts
import { realtimeChannelTrigger, s, ref } from "@xano/sdk";

export const onJoin = realtimeChannelTrigger({
  name: "on_room_join",
  channel: room,
  actions: { join: true },
  stack: () => [
    // A trigger cannot read inp("room_id"); the bound path params are on the session.
    s.realtime.get_session({ as: "session" }),
    s.debug.log({ value: ref("session.params.room_id") }),
  ],
  response: () => ({ allowed: ref("session.authenticated") }),
});

export const onDeliver = realtimeChannelTrigger({
  name: "on_room_deliver",
  channel: room,
  actions: { deliver: true },
  // Runs once per recipient. An object replaces this recipient's payload;
  // only null drops the message.
  response: (t) => ({ body: t.payload("body") }),
});

import { socketUrl, channelPath, type MessageInputs } from "../xano/routes.gen.js";

const ws = new WebSocket(socketUrl("chat", XANO_HOST), token); // the token is the subprotocol
const channel = channelPath("rooms/{room_id}", { room_id: 42 });
const payload: MessageInputs["rooms/{room_id} send"] = { body: "hi" };

ws.onopen = () =>
  setTimeout(() => {
    ws.send(JSON.stringify({ action: "join", channel }));
    ws.send(JSON.stringify({ action: "broadcast", channel, type: "send", payload }));
  }, 500);

ws.onmessage = (e) => {
  const frame = JSON.parse(e.data);
  if (frame.action === "message") console.log(frame.payload.body);
};

// A listen-only client keeps the socket alive.
setInterval(() => ws.send(JSON.stringify({ action: "ping" })), 60_000);