Lightweight Libraries for Backends

import { actor } from "rivetkit";
import { drizzle } from "@rivetkit/drizzle";
import { generateText, tool } from "ai";
import { openai } from "@ai-sdk/openai";
import { getWeather } from "./my-utils";
import { messages } from "./schema";

export type Message = { role: "user" | "assistant"; content: string; timestamp: number; }

const aiAgent = actor({
  sql: drizzle(),

  actions: {
    // Get conversation history
    getMessages: async (c) => {
      const result = await c.db
        .select()
        .from(messages)
        .orderBy(messages.timestamp.asc());
      
      return result;
    },

    // Send a message to the AI and get a response
    sendMessage: async (c, userMessage: string) => {
      const now = Date.now();
      
      // Add user message to conversation
      const userMsg = {
        conversationId: c.actorId, // Use the actor instance ID
        role: "user",
        content: userMessage,
      };
      
      // Store user message
      await c.db
        .insert(messages)
        .values(userMsg);
      
      // Get all messages
      const allMessages = await c.db
        .select()
        .from(messages)
        .orderBy(messages.timestamp.asc());
      
      // Generate AI response using Vercel AI SDK with tools
      const { text } = await generateText({
        model: openai("o3-mini"),
        prompt: userMessage,
        messages: allMessages,
        tools: {
          weather: tool({
            description: 'Get the weather in a location',
            parameters: {
              location: {
                type: 'string',
                description: 'The location to get the weather for',
              },
            },
            execute: async ({ location }) => {
              return await getWeather(location);
            },
          }),
        },
      });
      
      // Add AI response to conversation
      const assistantMsg = {
        role: "assistant",
        content: text,
      };
      
      // Store assistant message
      await c.db
        .insert(messages)
        .values(assistantMsg);
      
      // Broadcast the new message to all connected clients
      c.broadcast("messageReceived", assistantMsg);
      
      return assistantMsg;
    },
  }
});

export default aiAgent;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect } from "react";
import type { App } from "../actors/app";
import type { Message } from "./actor";

const client = createClient<App>("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function AIAssistant() {
  const [{ actor }] = useActor("aiAgent", { tags: { conversationId: "default" } });
  const [messages, setMessages] = useState<Message[]>([]);
  const [input, setInput] = useState("");
  const [isLoading, setIsLoading] = useState(false);

  // Load initial messages
  useEffect(() => {
    if (actor) {
      actor.getMessages().then(setMessages);
    }
  }, [actor]);

  // Listen for real-time messages
  useActorEvent({ actor, event: "messageReceived" }, (message) => {
    setMessages(prev => [...prev, message as Message]);
    setIsLoading(false);
  });

  const handleSendMessage = async () => {
    if (actor && input.trim()) {
      setIsLoading(true);
      
      // Add user message to UI immediately
      const userMessage = { role: "user", content: input } as Message;
      setMessages(prev => [...prev, userMessage]);
      
      // Send to actor (AI response will come through the event)
      await actor.sendMessage(input);
      setInput("");
    }
  };

  return (
    <div className="ai-chat">
      <div className="messages">
        {messages.length === 0 ? (
          <div className="empty-message">
            Ask the AI assistant a question to get started
          </div>
        ) : (
          messages.map((msg, i) => (
            <div key={i} className={`message ${msg.role}`}>
              <div className="avatar">
                {msg.role === "user" ? "👤" : "🤖"}
              </div>
              <div className="content">{msg.content}</div>
            </div>
          ))
        )}
        {isLoading && (
          <div className="message assistant loading">
            <div className="avatar">🤖</div>
            <div className="content">Thinking...</div>
          </div>
        )}
      </div>
      
      <div className="input-area">
        <input
          value={input}
          onChange={e => setInput(e.target.value)}
          onKeyPress={e => e.key === "Enter" && handleSendMessage()}
          placeholder="Ask the AI assistant..."
          disabled={isLoading}
        />
        <button 
          onClick={handleSendMessage}
          disabled={isLoading || !input.trim()}
        >
          Send
        </button>
      </div>
    </div>
  );
}

import { actor } from "rivetkit";
import * as Y from 'yjs';
import { encodeStateAsUpdate, applyUpdate } from 'yjs';

const yjsDocument = actor({
  // State: just the serialized Yjs document data
  state: {
    docData: "", // Base64 encoded Yjs document
    lastModified: 0
  },
  
  // In-memory Yjs objects (not serialized)
  createVars: () => ({
    doc: new Y.Doc()
  }),
  
  // Initialize document from state when actor starts
  onStart: (c) => {
    if (c.state.docData) {
      const binary = atob(c.state.docData);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) {
        bytes[i] = binary.charCodeAt(i);
      }
      applyUpdate(c.vars.doc, bytes);
    }
  },
  
  // Handle client connections
  onConnect: (c) => {
    // Send initial document state to client
    const update = encodeStateAsUpdate(c.vars.doc);
    const base64 = bufferToBase64(update);
    
    c.conn.send("initialState", { update: base64 });
  },


  actions: {
    // Apply a Yjs update from a client
    applyUpdate: (c, updateBase64: string) => {
      // Convert base64 to binary
      const binary = atob(updateBase64);
      const update = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) {
        update[i] = binary.charCodeAt(i);
      }
      
      // Apply update to Yjs document
      applyUpdate(c.vars.doc, update);
      
      // Save document state
      const fullState = encodeStateAsUpdate(c.vars.doc);
      c.state.docData = bufferToBase64(fullState);
      c.state.lastModified = Date.now();
      
      // Broadcast to all clients
      c.broadcast("update", { update: updateBase64 });
    }
  }
});

// Helper to convert ArrayBuffer to base64
function bufferToBase64(buffer: Uint8Array): string {
  let binary = '';
  for (let i = 0; i < buffer.byteLength; i++) {
    binary += String.fromCharCode(buffer[i]);
  }
  return btoa(binary);
}

export default yjsDocument;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect, useRef } from "react";
import * as Y from 'yjs';
import { applyUpdate, encodeStateAsUpdate } from 'yjs';
import type { App } from "../actors/app";

const client = createClient<App>("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function YjsEditor({ documentId = "shared-doc" }) {
  // Connect to specific document using tags
  const { actor } = useActor("yjsDocument", { 
    tags: { documentId }
  });
  
  // Document state
  const [isLoading, setIsLoading] = useState(true);
  const [text, setText] = useState("");
  
  // Local Yjs document
  const yDocRef = useRef<Y.Doc | null>(null);
  // Flag to prevent infinite update loops
  const updatingFromServer = useRef(false);
  const updatingFromLocal = useRef(false);
  // Track if we've initialized observation
  const observationInitialized = useRef(false);

  // Initialize local Yjs document and connect
  useEffect(() => {
    // Create Yjs document
    const yDoc = new Y.Doc();
    yDocRef.current = yDoc;
    setIsLoading(false);
    
    return () => {
      // Clean up Yjs document
      yDoc.destroy();
    };
  }, [actor]);
  
  // Set up text observation
  useEffect(() => {
    const yDoc = yDocRef.current;
    if (!yDoc || observationInitialized.current) return;
    
    // Get the Yjs Text type from the document
    const yText = yDoc.getText('content');
    
    // Observe changes to the text
    yText.observe(() => {
      // Only update UI if change wasn't from server
      if (!updatingFromServer.current) {
        // Update React state
        setText(yText.toString());
        
        if (actor && !updatingFromLocal.current) {
          // Set flag to prevent loops
          updatingFromLocal.current = true;
          
          // Convert update to base64 and send to server
          const update = encodeStateAsUpdate(yDoc);
          const base64 = bufferToBase64(update);
          actor.applyUpdate(base64).finally(() => {
            updatingFromLocal.current = false;
          });
        }
      }
    });
    
    observationInitialized.current = true;
  }, [actor]);

  // Handle initial state from server
  useActorEvent({ actor, event: "initialState" }, ({ update }) => {
    const yDoc = yDocRef.current;
    if (!yDoc) return;
    
    // Set flag to prevent update loops
    updatingFromServer.current = true;
    
    try {
      // Convert base64 to binary and apply to document
      const binary = atob(update);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) {
        bytes[i] = binary.charCodeAt(i);
      }
      
      // Apply update to Yjs document
      applyUpdate(yDoc, bytes);
      
      // Update React state
      const yText = yDoc.getText('content');
      setText(yText.toString());
    } catch (error) {
      console.error("Error applying initial update:", error);
    } finally {
      updatingFromServer.current = false;
    }
  });

  // Handle updates from other clients
  useActorEvent({ actor, event: "update" }, ({ update }) => {
    const yDoc = yDocRef.current;
    if (!yDoc) return;
    
    // Set flag to prevent update loops
    updatingFromServer.current = true;
    
    try {
      // Convert base64 to binary and apply to document
      const binary = atob(update);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) {
        bytes[i] = binary.charCodeAt(i);
      }
      
      // Apply update to Yjs document
      applyUpdate(yDoc, bytes);
      
      // Update React state
      const yText = yDoc.getText('content');
      setText(yText.toString());
    } catch (error) {
      console.error("Error applying update:", error);
    } finally {
      updatingFromServer.current = false;
    }
  });

  // Handle text changes from user
  const handleTextChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
    if (!yDocRef.current) return;
    
    const newText = e.target.value;
    const yText = yDocRef.current.getText('content');
    
    // Only update if text actually changed
    if (newText !== yText.toString()) {
      // Set flag to avoid loops
      updatingFromLocal.current = true;
      
      // Update Yjs document (this will trigger observe callback)
      yDocRef.current.transact(() => {
        yText.delete(0, yText.length);
        yText.insert(0, newText);
      });
      
      updatingFromLocal.current = false;
    }
  };

  if (isLoading) {
    return <div className="loading">Loading collaborative document...</div>;
  }

  return (
    <div className="yjs-editor">
      <h3>Collaborative Document: {documentId}</h3>
      <textarea
        value={text}
        onChange={handleTextChange}
        placeholder="Start typing... All changes are synchronized in real-time!"
        className="collaborative-textarea"
      />
    </div>
  );
}

// Helper to convert ArrayBuffer to base64
function bufferToBase64(buffer: Uint8Array): string {
  let binary = '';
  for (let i = 0; i < buffer.byteLength; i++) {
    binary += String.fromCharCode(buffer[i]);
  }
  return btoa(binary);
}

import { actor } from "rivetkit";
import { drizzle } from "@rivetkit/drizzle";
import * as Y from 'yjs';
import { encodeStateAsUpdate, applyUpdate } from 'yjs';
import { documents } from "./schema";

const yjsDocument = actor({
  sql: drizzle(),
  
  // In-memory Yjs objects (not serialized)
  createVars: () => ({
    doc: new Y.Doc()
  }),
  
  // Initialize document from state when actor starts
  onStart: async (c) => {
    // Get document data from database
    const documentData = await c.db
      .select()
      .from(documents)
      .get();
      
    if (documentData?.docData) {
      try {
        // Parse the docData from string to binary
        const binary = atob(documentData.docData);
        const bytes = new Uint8Array(binary.length);
        for (let i = 0; i < binary.length; i++) {
          bytes[i] = binary.charCodeAt(i);
        }
        applyUpdate(c.vars.doc, bytes);
      } catch (error) {
        console.error("Failed to load document", error);
      }
    }
  },
  
  // Handle client connections
  onConnect: (c) => {
    // Send initial document state to client
    const update = encodeStateAsUpdate(c.vars.doc);
    const base64 = bufferToBase64(update);
    
    c.conn.send("initialState", { update: base64 });
  },

  actions: {
    // Apply a Yjs update from a client
    applyUpdate: async (c, updateBase64: string) => {
      try {
        // Convert base64 to binary
        const binary = atob(updateBase64);
        const update = new Uint8Array(binary.length);
        for (let i = 0; i < binary.length; i++) {
          update[i] = binary.charCodeAt(i);
        }
        
        // Apply update to Yjs document
        applyUpdate(c.vars.doc, update);
        
        // Save document state to database
        const fullState = encodeStateAsUpdate(c.vars.doc);
        const docData = bufferToBase64(fullState);
        
        // Store in database
        await c.db
          .insert(documents)
          .values({
            docData
          })
          .onConflictDoUpdate({
            target: documents.id,
            set: {
              docData
            }
          });
        
        // Broadcast to all clients
        c.broadcast("update", { update: updateBase64 });
      } catch (error) {
        console.error("Failed to apply update", error);
      }
    }
  }
});

// Helper to convert ArrayBuffer to base64
function bufferToBase64(buffer: Uint8Array): string {
  let binary = '';
  for (let i = 0; i < buffer.byteLength; i++) {
    binary += String.fromCharCode(buffer[i]);
  }
  return btoa(binary);
}

export default yjsDocument;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect, useRef } from "react";
import * as Y from 'yjs';
import { applyUpdate, encodeStateAsUpdate } from 'yjs';
import type { App } from "../actors/app";

const client = createClient<App>("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function YjsEditor({ documentId = "shared-doc" }) {
  // Connect to specific document using tags
  const { actor } = useActor("yjsDocument", { 
    tags: { documentId }
  });
  
  // Document state
  const [isLoading, setIsLoading] = useState(true);
  const [text, setText] = useState("");
  
  // Local Yjs document
  const yDocRef = useRef<Y.Doc | null>(null);
  // Flag to prevent infinite update loops
  const updatingFromServer = useRef(false);
  const updatingFromLocal = useRef(false);
  // Track if we've initialized observation
  const observationInitialized = useRef(false);

  // Initialize local Yjs document and connect
  useEffect(() => {
    // Create Yjs document
    const yDoc = new Y.Doc();
    yDocRef.current = yDoc;
    setIsLoading(false);
    
    return () => {
      // Clean up Yjs document
      yDoc.destroy();
    };
  }, [actor]);
  
  // Set up text observation
  useEffect(() => {
    const yDoc = yDocRef.current;
    if (!yDoc || observationInitialized.current) return;
    
    // Get the Yjs Text type from the document
    const yText = yDoc.getText('content');
    
    // Observe changes to the text
    yText.observe(() => {
      // Only update UI if change wasn't from server
      if (!updatingFromServer.current) {
        // Update React state
        setText(yText.toString());
        
        if (actor && !updatingFromLocal.current) {
          // Set flag to prevent loops
          updatingFromLocal.current = true;
          
          // Convert update to base64 and send to server
          const update = encodeStateAsUpdate(yDoc);
          const base64 = bufferToBase64(update);
          actor.applyUpdate(base64).finally(() => {
            updatingFromLocal.current = false;
          });
        }
      }
    });
    
    observationInitialized.current = true;
  }, [actor]);

  // Handle initial state from server
  useActorEvent({ actor, event: "initialState" }, ({ update }) => {
    const yDoc = yDocRef.current;
    if (!yDoc) return;
    
    // Set flag to prevent update loops
    updatingFromServer.current = true;
    
    try {
      // Convert base64 to binary and apply to document
      const binary = atob(update);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) {
        bytes[i] = binary.charCodeAt(i);
      }
      
      // Apply update to Yjs document
      applyUpdate(yDoc, bytes);
      
      // Update React state
      const yText = yDoc.getText('content');
      setText(yText.toString());
    } catch (error) {
      console.error("Error applying initial update:", error);
    } finally {
      updatingFromServer.current = false;
    }
  });

  // Handle updates from other clients
  useActorEvent({ actor, event: "update" }, ({ update }) => {
    const yDoc = yDocRef.current;
    if (!yDoc) return;
    
    // Set flag to prevent update loops
    updatingFromServer.current = true;
    
    try {
      // Convert base64 to binary and apply to document
      const binary = atob(update);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) {
        bytes[i] = binary.charCodeAt(i);
      }
      
      // Apply update to Yjs document
      applyUpdate(yDoc, bytes);
      
      // Update React state
      const yText = yDoc.getText('content');
      setText(yText.toString());
    } catch (error) {
      console.error("Error applying update:", error);
    } finally {
      updatingFromServer.current = false;
    }
  });

  // Handle text changes from user
  const handleTextChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
    if (!yDocRef.current) return;
    
    const newText = e.target.value;
    const yText = yDocRef.current.getText('content');
    
    // Only update if text actually changed
    if (newText !== yText.toString()) {
      // Set flag to avoid loops
      updatingFromLocal.current = true;
      
      // Update Yjs document (this will trigger observe callback)
      yDocRef.current.transact(() => {
        yText.delete(0, yText.length);
        yText.insert(0, newText);
      });
      
      updatingFromLocal.current = false;
    }
  };

  if (isLoading) {
    return <div className="loading">Loading collaborative document...</div>;
  }

  return (
    <div className="yjs-editor">
      <h3>Collaborative Document: {documentId}</h3>
      <textarea
        value={text}
        onChange={handleTextChange}
        placeholder="Start typing... All changes are synchronized in real-time!"
        className="collaborative-textarea"
      />
    </div>
  );
}

// Helper to convert ArrayBuffer to base64
function bufferToBase64(buffer: Uint8Array): string {
  let binary = '';
  for (let i = 0; i < buffer.byteLength; i++) {
    binary += String.fromCharCode(buffer[i]);
  }
  return btoa(binary);
}

import { actor } from "rivetkit";

export type Message = { sender: string; text: string; timestamp: number; }

const chatRoom = actor({
  // State is automatically persisted
  state: { 
    messages: [] as Message[] 
  },

  actions: {
    sendMessage: (c, sender: string, text: string) => {
      const message = { sender, text, timestamp: Date.now() };
      
      // Any changes to state are automatically saved
      c.state.messages.push(message);
      
      // Broadcast events trigger real-time updates in connected clients
      c.broadcast("newMessage", message);
    },

    getHistory: (c) => c.state.messages
  }
});

export default chatRoom;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect } from "react";
import type { App } from "../actors/app";
import type { Message } from "./actor";

const client = createClient<App>("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function ChatRoom({ roomId = "general" }) {
  // Connect to specific chat room using tags
  const [{ actor }] = useActor("chatRoom", { 
    tags: { roomId }
  });
  
  const [messages, setMessages] = useState<Message[]>([]);
  const [input, setInput] = useState("");

  // Load initial state
  useEffect(() => {
    if (actor) {
      // Load chat history
      actor.getHistory().then(setMessages);
    }
  }, [actor]);

  // Listen for real-time updates from the server
  useActorEvent({ actor, event: "newMessage" }, (message) => {
    setMessages(prev => [...prev, message]);
  });

  const sendMessage = () => {
    if (actor && input.trim()) {
      actor.sendMessage("User", input);
      setInput("");
    }
  };

  return (
    <div className="chat-container">
      <div className="room-header">
        <h3>Chat Room: {roomId}</h3>
      </div>
      
      <div className="messages">
        {messages.length === 0 ? (
          <div className="empty-message">No messages yet. Start the conversation!</div>
        ) : (
          messages.map((msg, i) => (
            <div key={i} className="message">
              <b>{msg.sender}:</b> {msg.text}
              <span className="timestamp">
                {new Date(msg.timestamp).toLocaleTimeString()}
              </span>
            </div>
          ))
        )}
      </div>
      
      <div className="input-area">
        <input
          value={input}
          onChange={e => setInput(e.target.value)}
          onKeyPress={e => e.key === "Enter" && sendMessage()}
          placeholder="Type a message..."
        />
        <button onClick={sendMessage}>Send</button>
      </div>
    </div>
  );
}

import { actor } from "rivetkit";
import { drizzle } from "@rivetkit/drizzle";
import { messages } from "./schema";

export type Message = { sender: string; text: string; timestamp: number; }

const chatRoom = actor({
  sql: drizzle(),

  actions: {
    sendMessage: async (c, sender: string, text: string) => {
      const message = {
        sender,
        text,
        timestamp: Date.now(),
      };

      // Insert the message into SQLite
      await c.db.insert(messages).values(message);
      
      // Broadcast to all connected clients
      c.broadcast("newMessage", message);
      
      // Return the created message (matches JS memory version)
      return message;
    },

    getHistory: async (c) => {
      // Query all messages ordered by timestamp
      const result = await c.db
        .select()
        .from(messages)
        .orderBy(messages.timestamp);
      
      return result as Message[];
    }
  }
});

export default chatRoom;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect } from "react";
import type { App } from "../actors/app";
import type { Message } from "./actor";

const client = createClient<App>("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function ChatRoom({ roomId = "general" }) {
  // Connect to specific chat room using tags
  const [{ actor }] = useActor("chatRoom", { 
    tags: { roomId }
  });
  
  const [messages, setMessages] = useState<Message[]>([]);
  const [input, setInput] = useState("");

  // Load initial state
  useEffect(() => {
    if (actor) {
      // Load chat history
      actor.getHistory().then(setMessages);
    }
  }, [actor]);

  // Listen for real-time updates from the server
  useActorEvent({ actor, event: "newMessage" }, (message) => {
    setMessages(prev => [...prev, message]);
  });

  const sendMessage = () => {
    if (actor && input.trim()) {
      actor.sendMessage("User", input);
      setInput("");
    }
  };

  return (
    <div className="chat-container">
      <div className="room-header">
        <h3>Chat Room: {roomId}</h3>
      </div>
      
      <div className="messages">
        {messages.length === 0 ? (
          <div className="empty-message">No messages yet. Start the conversation!</div>
        ) : (
          messages.map((msg, i) => (
            <div key={i} className="message">
              <b>{msg.sender}:</b> {msg.text}
              <span className="timestamp">
                {new Date(msg.timestamp).toLocaleTimeString()}
              </span>
            </div>
          ))
        )}
      </div>
      
      <div className="input-area">
        <input
          value={input}
          onChange={e => setInput(e.target.value)}
          onKeyPress={e => e.key === "Enter" && sendMessage()}
          placeholder="Type a message..."
        />
        <button onClick={sendMessage}>Send</button>
      </div>
    </div>
  );
}

import { actor } from "rivetkit";
import { authenticate } from "./my-utils";

export type Note = { id: string; content: string; updatedAt: number };

// User notes actor
const notes = actor({
  state: {
    notes: [] as Note[]
  },
  
  // Authenticate
  createConnState: async (c, { params }) => {
    const token = params.token;
	const userId = await authenticate(token);
    return { userId };
  },

  actions: {
    // Get all notes
    getNotes: (c) => c.state.notes,

    // Update note or create if it doesn't exist
    updateNote: (c, { id, content }) => {
      const noteIndex = c.state.notes.findIndex(note => note.id === id);
      let note;
      
      if (noteIndex >= 0) {
        // Update existing note
        note = c.state.notes[noteIndex];
        note.content = content;
        note.updatedAt = Date.now();
        c.broadcast("noteUpdated", note);
      } else {
        // Create new note
        note = {
          id: id || `note-${Date.now()}`,
          content,
          updatedAt: Date.now()
        };
        c.state.notes.push(note);
        c.broadcast("noteAdded", note);
      }
      
      return note;
    },

    // Delete note
    deleteNote: (c, { id }) => {
      const noteIndex = c.state.notes.findIndex(note => note.id === id);
      if (noteIndex >= 0) {
        c.state.notes.splice(noteIndex, 1);
        c.broadcast("noteDeleted", { id });
      }
    }
  }
});

export default notes;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect } from "react";

const client = createClient("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function NotesApp({ userId }: { userId: string }) {
  const [notes, setNotes] = useState<Array<{ id: string, content: string }>>([]);
  const [newNote, setNewNote] = useState("");
  
  // Connect to actor with auth token
  const [{ actor }] = useActor("notes", { 
    params: { userId, token: "demo-token" }
  });
  
  // Load initial notes
  useEffect(() => {
    if (actor) {
      actor.getNotes().then(setNotes);
    }
  }, [actor]);
  
  // Add a new note
  const addNote = async () => {
    if (actor && newNote.trim()) {
      await actor.updateNote({ id: `note-${Date.now()}`, content: newNote });
      setNewNote("");
    }
  };
  
  // Delete a note
  const deleteNote = (id: string) => {
    if (actor) {
      actor.deleteNote({ id });
    }
  };
  
  // Listen for realtime updates
  useActorEvent({ actor, event: "noteAdded" }, (note) => {
    setNotes(notes => [...notes, note]);
  });
  
  useActorEvent({ actor, event: "noteUpdated" }, (updatedNote) => {
    setNotes(notes => notes.map(note => 
      note.id === updatedNote.id ? updatedNote : note
    ));
  });
  
  useActorEvent({ actor, event: "noteDeleted" }, ({ id }) => {
    setNotes(notes => notes.filter(note => note.id !== id));
  });
  
  return (
    <div>
      <h2>My Notes</h2>
      
      <div>
        <input 
          value={newNote}
          onChange={e => setNewNote(e.target.value)}
          placeholder="Enter a new note"
        />
        <button onClick={addNote}>Add</button>
      </div>
      
      <ul>
        {notes.map(note => (
          <li key={note.id}>
            {note.content}
            <button onClick={() => deleteNote(note.id)}>Delete</button>
          </li>
        ))}
      </ul>
    </div>
  );
}

import { actor } from "rivetkit";
import { drizzle } from "@rivetkit/drizzle";
import { notes } from "./schema";
import { authenticate } from "./my-utils";

export type Note = { id: string; content: string; updatedAt: number };

// User notes actor
const userNotes = actor({
  sql: drizzle(),
  
  // Authenticate
  createConnState: async (c, { params }) => {
    const token = params.token;
    const userId = await authenticate(token);
    return { userId };
  },

  actions: {
    // Get all notes
    getNotes: async (c) => {
      const result = await c.db
        .select()
        .from(notes);
      
      return result;
    },

    // Update note or create if it doesn't exist
    updateNote: async (c, { id, content }) => {
      // Ensure the note ID exists or create a new one
      const noteId = id || `note-${Date.now()}`;
      
      // Check if note exists
      const existingNote = await c.db
        .select()
        .from(notes)
        .where(notes.id.equals(noteId))
        .get();
      
      if (existingNote) {
        // Update existing note
        await c.db
          .update(notes)
          .set({
            content
          })
          .where(notes.id.equals(noteId));
        
        const updatedNote = {
          id: noteId,
          content
        };
        
        c.broadcast("noteUpdated", updatedNote);
        return updatedNote;
      } else {
        // Create new note
        const newNote = {
          id: noteId,
          content
        };
        
        await c.db
          .insert(notes)
          .values(newNote);
        
        c.broadcast("noteAdded", newNote);
        return newNote;
      }
    },

    // Delete note
    deleteNote: async (c, { id }) => {
      // Delete the note
      await c.db
        .delete(notes)
        .where(notes.id.equals(id));
      
      c.broadcast("noteDeleted", { id });
    }
  }
});

export default userNotes;

import { createClient } from "rivetkit/client";
import { createReactRivetKit } from "@rivetkit/react";
import { useState, useEffect } from "react";

const client = createClient("http://localhost:8080");
const { useActor, useActorEvent } = createReactRivetKit(client);

export function NotesApp({ userId }: { userId: string }) {
  const [notes, setNotes] = useState<Array<{ id: string, content: string }>>([]);
  const [newNote, setNewNote] = useState("");
  
  // Connect to actor with auth token
  const [{ actor }] = useActor("notes", { 
    params: { userId, token: "demo-token" }
  });
  
  // Load initial notes
  useEffect(() => {
    if (actor) {
      actor.getNotes().then(setNotes);
    }
  }, [actor]);
  
  // Add a new note
  const addNote = async () => {
    if (actor && newNote.trim()) {
      await actor.updateNote({ id: `note-${Date.now()}`, content: newNote });
      setNewNote("");
    }
  };
  
  // Delete a note
  const deleteNote = (id: string) => {
    if (actor) {
      actor.deleteNote({ id });
    }
  };
  
  // Listen for realtime updates
  useActorEvent({ actor, event: "noteAdded" }, (note) => {
    setNotes(notes => [...notes, note]);
  });
  
  useActorEvent({ actor, event: "noteUpdated" }, (updatedNote) => {
    setNotes(notes => notes.map(note => 
      note.id === updatedNote.id ? updatedNote : note
    ));
  });
  
  useActorEvent({ actor, event: "noteDeleted" }, ({ id }) => {
    setNotes(notes => notes.filter(note => note.id !== id));
  });
  
  return (
    <div>
      <h2>My Notes</h2>
      
      <div>
        <input 
          value={newNote}
          onChange={e => setNewNote(e.target.value)}
          placeholder="Enter a new note"
        />
        <button onClick={addNote}>Add</button>
      </div>
      
      <ul>
        {notes.map(note => (
          <li key={note.id}>
            {note.content}
            <button onClick={() => deleteNote(note.id)}>Delete</button>
          </li>
        ))}
      </ul>
    </div>
  );
}

import { actor } from "rivetkit";

// Simple rate limiter - allows 5 requests per minute
const rateLimiter = actor({
  state: {
    count: 0,
    resetAt: 0
  },

  actions: {
    // Check if request is allowed
    checkLimit: (c) => {
      const now = Date.now();
      
      // Reset if expired
      if (now > c.state.resetAt) {
        c.state.count = 0;
        c.state.resetAt = now + 60000; // 1 minute window
      }
      
      // Check if under limit
      const allowed = c.state.count < 5;
      
      // Increment if allowed
      if (allowed) {
        c.state.count++;
      }
      
      return {
        allowed,
        remaining: 5 - c.state.count,
        resetsIn: Math.round((c.state.resetAt - now) / 1000)
      };
    }
  }
});

export default rateLimiter;