@xtr-dev/rondevu-server 0.0.1

package/src/storage/sqlite.ts

@@ -0,0 +1,258 @@
+import Database from 'better-sqlite3';
+import { randomUUID } from 'crypto';
+import { Storage, Session } from './types.ts';
+
+/**
+ * SQLite storage adapter for session management
+ * Supports both file-based and in-memory databases
+ */
+export class SQLiteStorage implements Storage {
+  private db: Database.Database;
+
+  /**
+   * Creates a new SQLite storage instance
+   * @param path Path to SQLite database file, or ':memory:' for in-memory database
+   */
+  constructor(path: string = ':memory:') {
+    this.db = new Database(path);
+    this.initializeDatabase();
+    this.startCleanupInterval();
+  }
+
+  /**
+   * Initializes database schema
+   */
+  private initializeDatabase(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        code TEXT PRIMARY KEY,
+        origin TEXT NOT NULL,
+        topic TEXT NOT NULL,
+        info TEXT NOT NULL CHECK(length(info) <= 1024),
+        offer TEXT NOT NULL,
+        answer TEXT,
+        offer_candidates TEXT NOT NULL DEFAULT '[]',
+        answer_candidates TEXT NOT NULL DEFAULT '[]',
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_expires_at ON sessions(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_origin_topic ON sessions(origin, topic);
+      CREATE INDEX IF NOT EXISTS idx_origin_topic_expires ON sessions(origin, topic, expires_at);
+    `);
+  }
+
+  /**
+   * Starts periodic cleanup of expired sessions
+   */
+  private startCleanupInterval(): void {
+    // Run cleanup every minute
+    setInterval(() => {
+      this.cleanup().catch(err => {
+        console.error('Cleanup error:', err);
+      });
+    }, 60000);
+  }
+
+  /**
+   * Generates a unique code using UUID
+   */
+  private generateCode(): string {
+    return randomUUID();
+  }
+
+  async createSession(origin: string, topic: string, info: string, offer: string, expiresAt: number): Promise<string> {
+    // Validate info length
+    if (info.length > 1024) {
+      throw new Error('Info string must be 1024 characters or less');
+    }
+
+    let code: string;
+    let attempts = 0;
+    const maxAttempts = 10;
+
+    // Try to generate a unique code
+    do {
+      code = this.generateCode();
+      attempts++;
+
+      if (attempts > maxAttempts) {
+        throw new Error('Failed to generate unique session code');
+      }
+
+      try {
+        const stmt = this.db.prepare(`
+          INSERT INTO sessions (code, origin, topic, info, offer, created_at, expires_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `);
+
+        stmt.run(code, origin, topic, info, offer, Date.now(), expiresAt);
+        break;
+      } catch (err: any) {
+        // If unique constraint failed, try again
+        if (err.code === 'SQLITE_CONSTRAINT_PRIMARYKEY') {
+          continue;
+        }
+        throw err;
+      }
+    } while (true);
+
+    return code;
+  }
+
+  async listSessionsByTopic(origin: string, topic: string): Promise<Session[]> {
+    const stmt = this.db.prepare(`
+      SELECT * FROM sessions
+      WHERE origin = ? AND topic = ? AND expires_at > ? AND answer IS NULL
+      ORDER BY created_at DESC
+    `);
+
+    const rows = stmt.all(origin, topic, Date.now()) as any[];
+
+    return rows.map(row => ({
+      code: row.code,
+      origin: row.origin,
+      topic: row.topic,
+      info: row.info,
+      offer: row.offer,
+      answer: row.answer || undefined,
+      offerCandidates: JSON.parse(row.offer_candidates),
+      answerCandidates: JSON.parse(row.answer_candidates),
+      createdAt: row.created_at,
+      expiresAt: row.expires_at,
+    }));
+  }
+
+  async listTopics(origin: string, page: number, limit: number): Promise<{
+    topics: Array<{ topic: string; count: number }>;
+    pagination: {
+      page: number;
+      limit: number;
+      total: number;
+      hasMore: boolean;
+    };
+  }> {
+    // Ensure limit doesn't exceed 1000
+    const safeLimit = Math.min(Math.max(1, limit), 1000);
+    const safePage = Math.max(1, page);
+    const offset = (safePage - 1) * safeLimit;
+
+    // Get total count of topics
+    const countStmt = this.db.prepare(`
+      SELECT COUNT(DISTINCT topic) as total
+      FROM sessions
+      WHERE origin = ? AND expires_at > ? AND answer IS NULL
+    `);
+    const { total } = countStmt.get(origin, Date.now()) as any;
+
+    // Get paginated topics
+    const stmt = this.db.prepare(`
+      SELECT topic, COUNT(*) as count
+      FROM sessions
+      WHERE origin = ? AND expires_at > ? AND answer IS NULL
+      GROUP BY topic
+      ORDER BY topic ASC
+      LIMIT ? OFFSET ?
+    `);
+
+    const rows = stmt.all(origin, Date.now(), safeLimit, offset) as any[];
+
+    const topics = rows.map(row => ({
+      topic: row.topic,
+      count: row.count,
+    }));
+
+    return {
+      topics,
+      pagination: {
+        page: safePage,
+        limit: safeLimit,
+        total,
+        hasMore: offset + topics.length < total,
+      },
+    };
+  }
+
+  async getSession(code: string, origin: string): Promise<Session | null> {
+    const stmt = this.db.prepare(`
+      SELECT * FROM sessions WHERE code = ? AND origin = ? AND expires_at > ?
+    `);
+
+    const row = stmt.get(code, origin, Date.now()) as any;
+
+    if (!row) {
+      return null;
+    }
+
+    return {
+      code: row.code,
+      origin: row.origin,
+      topic: row.topic,
+      info: row.info,
+      offer: row.offer,
+      answer: row.answer || undefined,
+      offerCandidates: JSON.parse(row.offer_candidates),
+      answerCandidates: JSON.parse(row.answer_candidates),
+      createdAt: row.created_at,
+      expiresAt: row.expires_at,
+    };
+  }
+
+  async updateSession(code: string, origin: string, update: Partial<Session>): Promise<void> {
+    const current = await this.getSession(code, origin);
+
+    if (!current) {
+      throw new Error('Session not found or origin mismatch');
+    }
+
+    const updates: string[] = [];
+    const values: any[] = [];
+
+    if (update.answer !== undefined) {
+      updates.push('answer = ?');
+      values.push(update.answer);
+    }
+
+    if (update.offerCandidates !== undefined) {
+      updates.push('offer_candidates = ?');
+      values.push(JSON.stringify(update.offerCandidates));
+    }
+
+    if (update.answerCandidates !== undefined) {
+      updates.push('answer_candidates = ?');
+      values.push(JSON.stringify(update.answerCandidates));
+    }
+
+    if (updates.length === 0) {
+      return;
+    }
+
+    values.push(code);
+    values.push(origin);
+
+    const stmt = this.db.prepare(`
+      UPDATE sessions SET ${updates.join(', ')} WHERE code = ? AND origin = ?
+    `);
+
+    stmt.run(...values);
+  }
+
+  async deleteSession(code: string): Promise<void> {
+    const stmt = this.db.prepare('DELETE FROM sessions WHERE code = ?');
+    stmt.run(code);
+  }
+
+  async cleanup(): Promise<void> {
+    const stmt = this.db.prepare('DELETE FROM sessions WHERE expires_at <= ?');
+    const result = stmt.run(Date.now());
+
+    if (result.changes > 0) {
+      console.log(`Cleaned up ${result.changes} expired session(s)`);
+    }
+  }
+
+  async close(): Promise<void> {
+    this.db.close();
+  }
+}

package/src/storage/types.ts

@@ -0,0 +1,90 @@
+/**
+ * Represents a WebRTC signaling session
+ */
+export interface Session {
+  code: string;
+  origin: string;
+  topic: string;
+  info: string;
+  offer: string;
+  answer?: string;
+  offerCandidates: string[];
+  answerCandidates: string[];
+  createdAt: number;
+  expiresAt: number;
+}
+
+/**
+ * Storage interface for session management
+ * Implementations can use different backends (SQLite, Redis, Memory, etc.)
+ */
+export interface Storage {
+  /**
+   * Creates a new session with the given offer
+   * @param origin The Origin header from the request
+   * @param topic The topic to post the offer to
+   * @param info User info string (max 1024 chars)
+   * @param offer The WebRTC SDP offer message
+   * @param expiresAt Unix timestamp when the session should expire
+   * @returns The unique session code
+   */
+  createSession(origin: string, topic: string, info: string, offer: string, expiresAt: number): Promise<string>;
+
+  /**
+   * Lists all unanswered sessions for a given origin and topic
+   * @param origin The Origin header from the request
+   * @param topic The topic to list offers for
+   * @returns Array of sessions that haven't been answered yet
+   */
+  listSessionsByTopic(origin: string, topic: string): Promise<Session[]>;
+
+  /**
+   * Lists all topics for a given origin with their session counts
+   * @param origin The Origin header from the request
+   * @param page Page number (starting from 1)
+   * @param limit Number of results per page (max 1000)
+   * @returns Object with topics array and pagination metadata
+   */
+  listTopics(origin: string, page: number, limit: number): Promise<{
+    topics: Array<{ topic: string; count: number }>;
+    pagination: {
+      page: number;
+      limit: number;
+      total: number;
+      hasMore: boolean;
+    };
+  }>;
+
+  /**
+   * Retrieves a session by its code
+   * @param code The session code
+   * @param origin The Origin header from the request (for validation)
+   * @returns The session if found, null otherwise
+   */
+  getSession(code: string, origin: string): Promise<Session | null>;
+
+  /**
+   * Updates an existing session with new data
+   * @param code The session code
+   * @param origin The Origin header from the request (for validation)
+   * @param update Partial session data to update
+   */
+  updateSession(code: string, origin: string, update: Partial<Session>): Promise<void>;
+
+  /**
+   * Deletes a session
+   * @param code The session code
+   */
+  deleteSession(code: string): Promise<void>;
+
+  /**
+   * Removes expired sessions
+   * Should be called periodically to clean up old data
+   */
+  cleanup(): Promise<void>;
+
+  /**
+   * Closes the storage connection and releases resources
+   */
+  close(): Promise<void>;
+}

package/src/worker.ts

@@ -0,0 +1,39 @@
+import { createApp } from './app.ts';
+import { KVStorage } from './storage/kv.ts';
+
+/**
+ * Cloudflare Workers environment bindings
+ */
+export interface Env {
+  SESSIONS: KVNamespace;
+  SESSION_TIMEOUT?: string;
+  CORS_ORIGINS?: string;
+}
+
+/**
+ * Cloudflare Workers fetch handler
+ */
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    // Initialize KV storage
+    const storage = new KVStorage(env.SESSIONS);
+
+    // Parse configuration
+    const sessionTimeout = env.SESSION_TIMEOUT
+      ? parseInt(env.SESSION_TIMEOUT, 10)
+      : 300000; // 5 minutes default
+
+    const corsOrigins = env.CORS_ORIGINS
+      ? env.CORS_ORIGINS.split(',').map(o => o.trim())
+      : ['*'];
+
+    // Create Hono app
+    const app = createApp(storage, {
+      sessionTimeout,
+      corsOrigins,
+    });
+
+    // Handle request
+    return app.fetch(request, env, ctx);
+  },
+};

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "types": ["@types/node", "@cloudflare/workers-types"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/wrangler.toml.example

@@ -0,0 +1,26 @@
+name = "rondevu"
+main = "src/worker.ts"
+compatibility_date = "2024-01-01"
+
+# KV Namespace binding
+[[kv_namespaces]]
+binding = "SESSIONS"
+id = ""  # Replace with your KV namespace ID
+
+# Environment variables
+[vars]
+SESSION_TIMEOUT = "300000"  # 5 minutes in milliseconds
+CORS_ORIGINS = "*"  # Comma-separated list of allowed origins
+
+# Build configuration
+[build]
+command = ""
+
+# For local development
+# Run: npx wrangler dev
+# The local KV will be created automatically
+
+# For production deployment:
+# 1. Create KV namespace: npx wrangler kv:namespace create SESSIONS
+# 2. Update the 'id' field above with the returned namespace ID
+# 3. Deploy: npx wrangler deploy