API Reference

import { yjs } from "@pluv/crdt-yjs";
import { createIO } from "@pluv/io";
import { platformNode } from "@pluv/platform-node";
import { z } from "zod";
import { Database } from "./db";

const io = createIO({
    // Optional: if provided, defines authorization for rooms created by io
    authorize: {
        // If required is false, users can authenticate for a room to
        // attach an identity to their presence. Otherwise they will be
        // anonymous.
        required: true,
        // The secret for generating your JWT
        secret: process.env.PLUV_AUTH_SECRET!,
        // The shape of your user object. `id` must always be required.
        user: z.object({
            id: z.string(),
            // Here is an additional field we wish to add.
            name: z.string(),
        }),
    },
    // Optional: if provided, this context will be made available in event
    // handlers and procedures
    context: () => ({
        db: new Database(process.env.DATABASE_URL),
    }),
    // Optional. Specify to use Yjs CRDT for storage.
    // This is required only if/when you wish to use storage features.
    crdt: yjs,
    // Enable @pluv/io for Node.js
    platform: platformNode(),
});

const token = await io.createToken({
    // If using @platform/node
    req: req as IncomingMessage,

    // If using @platform/cloudflare
    // This is the env from the Cloudflare worker handler's fetch function
    env: env as Env,
    request: request as Request,

    // ...
    room: "my-example-room",
    user: {
        id: "abc123",
        name: "leedavidcs",
    },
});

import { createIO } from "@pluv/io";
import { platformNode } from "@pluv/platform-node";
import { z } from "zod";

const io = createIO({ platform: platformNode() });

const sendMessage = io.procedure
    .input(z.object({ message: z.string() }))
    .broadcast(({ message }) => ({ receiveMessage: { message } }));

const doubleValue = io.procedure
    .input(z.object({ value: z.number() }))
    .broadcast(({ value }) => ({ receiveValue: { value: value * 2 } }));

const wave = io.procedure
    .broadcast(() => ({ receiveMessage: { message: "Hello world!" } }));

import { createIO } from "@pluv/io";
import { platformNode } from "@pluv/platform-node";
import { z } from "zod";

const io = createIO({ platform: platformNode() });

const sendMessage = io.procedure
    .input(z.object({ message: z.string() }))
    .broadcast(({ message }) => ({ receiveMessage: { message } }));

const doubleValue = io.procedure
    .input(z.object({ value: z.number() }))
    .broadcast(({ value }) => ({ receiveValue: { value: value * 2 } }));

const wave = io.procedure
    .broadcast(() => ({ receiveMessage: { message: "Hello world!" } }));

const router = io.router({
    sendMessage,
    doubleValue,
    wave,
});

import { createIO } from "@pluv/io";
import { platformNode } from "@pluv/platform-node";
import { z } from "zod";

const io = createIO({ platform: platformNode() });
const router = io.router({ /* ... */ });

const server = io.server({
    // Optional. Only needed to load persisted storage for rooms.
    // Load storage for a newly created room.
    getInitialStorage: async ({ room }) => {
        const existingRoom = await db.room.findUnique({ where: { room } });

        return existingRoom?.encodedState ?? null;
    },
    // Optional. Only needed for persisting storage for rooms.
    // Before the room is destroyed, persist the state to a database to load
    // when the room is re-created.
    onRoomDeleted: async ({ encodedState, room }) => {
        await db.room.upsert({
            where: { room },
            create: { encodedState, room },
            update: { encodedState },
        });
    },
    // Optional. It is unnecessary to save the storage state in this listener.
    // If a room already exists, users will load the currently active storage
    // before the storage from initialStorage.
    onStorageUpdated: ({ encodedState, room }) => {
        console.log(room, encodedState);
    },
    // Optional. Only needed if specifying events
    router,
});

// Can also be created without a router, if events are unneeded
const server = io.server();

const room = server.createRoom("my-example-room");

// The below 2 statements are equivalent
room.broadcast("sendMessage", { message: "Hello world~!" });

room.broadcast.sendMessage({ message: "Hello world~!" });

const roomId = room.id;

// const token: string = ...

room.register(webSocket, { token });