In-Memory State

import { actor } from "rivetkit";

const counter = actor({
  // Constant initial state
  state: { count: 0 },

  actions: {
    get: (c) => c.state.count,

    // Update state, changes are persisted automatically
    increment: (c) => {
      c.state.count += 1;
      return c.state.count;
    }
  }
});

import { actor } from "rivetkit";

interface CounterState {
  count: number;
}

const counter = actor({
  // Compute the initial state when the actor is created
  createState: (): CounterState => ({ count: 0 }),

  actions: {
    get: (c) => c.state.count,

    increment: (c) => {
      c.state.count += 1;
      return c.state.count;
    }
  }
});

import { actor } from "rivetkit";

interface CounterState {
  count: number;
}

const counter = actor({
  // Compute the initial state from input passed at creation
  createState: (c, input: { startingCount: number }): CounterState => ({
    count: input.startingCount,
  }),

  actions: {
    get: (c) => c.state.count,

    increment: (c) => {
      c.state.count += 1;
      return c.state.count;
    }
  }
});

import { actor } from "rivetkit";

const counter = actor({
  state: { count: 0 },

  // Constant ephemeral value, reset each time the actor starts
  vars: { lastAccessedAt: 0 },

  actions: {
    increment: (c) => {
      // Read and write the ephemeral var
      c.vars.lastAccessedAt = Date.now();
      return ++c.state.count;
    },

    getLastAccessed: (c) => c.vars.lastAccessedAt
  }
});

import { actor } from "rivetkit";

const chatRoom = actor({
  state: { messages: [] as string[] },

  // Build a non-serializable emitter on each start
  createVars: () => ({ emitter: createEventEmitter() }),

  actions: {
    broadcast: (c, text: string) => {
      c.state.messages.push(text);
      // Use the ephemeral emitter
      c.vars.emitter.emit("message", text);
    }
  }
});

// Mock event emitter for demonstration
interface EventEmitter {
  on: (event: string, callback: (data: unknown) => void) => void;
  emit: (event: string, data: unknown) => void;
}

function createEventEmitter(): EventEmitter {
  const listeners: Record<string, ((data: unknown) => void)[]> = {};
  return {
    on: (event, callback) => {
      listeners[event] = listeners[event] || [];
      listeners[event].push(callback);
    },
    emit: (event, data) => {
      listeners[event]?.forEach(cb => cb(data));
    }
  };
}

import { actor } from "rivetkit";
import { Pool } from "pg";

// One shared pool for the whole process, created once and reused by every actor
const pool = new Pool({ connectionString: process.env.DATABASE_URL });

const userActor = actor({
  state: { profile: null as Record<string, unknown> | null },

  // Load this actor's row from the shared pool on each start
  createVars: async (c) => {
    const { rows } = await pool.query("SELECT * FROM users WHERE id = $1", [c.key[0]]);
    return { profile: rows[0] };
  },

  actions: {
    updateEmail: async (c, email: string) => {
      await pool.query("UPDATE users SET email = $1 WHERE id = $2", [email, c.key[0]]);
    }
  }
});

import { actor } from "rivetkit";
import { db } from "rivetkit/db";

const todoList = actor({
  db: db({
    onMigrate: async (db) => {
      await db.execute(`
        CREATE TABLE IF NOT EXISTS todos (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          title TEXT NOT NULL
        );
      `);
    },
  }),

  actions: {
    add: async (c, title: string) => {
      await c.db.execute("INSERT INTO todos (title) VALUES (?)", title);
    },

    list: async (c) => {
      return (await c.db.execute(
        "SELECT id, title FROM todos ORDER BY id DESC",
      )) as { id: number; title: string }[];
    },
  },
});

import { actor } from "rivetkit";
import { db } from "rivetkit/db";

const counter = actor({
  db: db({
    onMigrate: async (db) => {
      await db.execute(`
        CREATE TABLE IF NOT EXISTS counter (
          id INTEGER PRIMARY KEY CHECK (id = 1),
          count INTEGER NOT NULL
        );
      `);
      await db.execute("INSERT OR IGNORE INTO counter (id, count) VALUES (1, 0)");
    },
  }),

  // Load the count from SQLite into memory on every start
  createVars: async (c) => {
    const rows = (await c.db.execute(
      "SELECT count FROM counter WHERE id = 1",
    )) as { count: number }[];
    return { count: rows[0].count };
  },

  actions: {
    get: (c) => c.vars.count,

    increment: async (c) => {
      // Update the in-memory value and write it back to SQLite
      c.vars.count += 1;
      await c.db.execute("UPDATE counter SET count = ? WHERE id = 1", c.vars.count);
      return c.vars.count;
    },
  },
});