@prsm/realtime 1.0.0

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@prsm/realtime",
+  "version": "1.0.0",
+  "description": "Distributed WebSocket framework with Redis-backed rooms, records, presence, channels, collections, and persistence",
+  "type": "module",
+  "license": "ISC",
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./src/client/index.js",
+    "./sqlite": "./src/adapters/sqlite.js",
+    "./postgres": "./src/adapters/postgres.js",
+    "./devtools": "./src/devtools/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "vitest run --reporter verbose"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "eventemitter3": "^5.0.1",
+    "fast-json-patch": "^3.1.1",
+    "ioredis": "^5.6.1",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0 || ^5.0.0",
+    "pg": "^8.0.0",
+    "sqlite3": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "ioredis": "^5.6.1",
+    "vitest": "^3.2.4"
+  }
+}

package/src/adapters/postgres.js

@@ -0,0 +1,139 @@
+import { convertToSqlPattern } from "../server/utils/pattern-conversion.js"
+import { serverLogger } from "../shared/index.js"
+
+export function createPostgresAdapter(options = {}) {
+  const opts = {
+    host: "localhost",
+    port: 5432,
+    database: "mesh_test",
+    user: "mesh",
+    password: "mesh_password",
+    max: 10,
+    ...options,
+  }
+  let pool = null
+  let initialized = false
+
+  async function createTables() {
+    if (!pool) throw new Error("Database not initialized")
+    const client = await pool.connect()
+    try {
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS channel_messages (
+          id TEXT PRIMARY KEY, channel TEXT NOT NULL, message TEXT NOT NULL,
+          instance_id TEXT NOT NULL, timestamp BIGINT NOT NULL, metadata JSONB
+        )
+      `)
+      await client.query(`CREATE INDEX IF NOT EXISTS idx_channel_timestamp ON channel_messages (channel, timestamp)`)
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS records (
+          record_id TEXT PRIMARY KEY, version INTEGER NOT NULL,
+          value JSONB NOT NULL, timestamp BIGINT NOT NULL
+        )
+      `)
+      await client.query(`CREATE INDEX IF NOT EXISTS idx_records_timestamp ON records (timestamp)`)
+    } finally { client.release() }
+  }
+
+  return {
+    async initialize() {
+      if (initialized) return
+      try {
+        const pg = await import("pg")
+        const Pool = pg.default?.Pool || pg.Pool
+        pool = new Pool(
+          opts.connectionString
+            ? { connectionString: opts.connectionString, max: opts.max }
+            : { host: opts.host, port: opts.port, database: opts.database, user: opts.user, password: opts.password, ssl: opts.ssl, max: opts.max }
+        )
+        await createTables()
+        initialized = true
+      } catch (err) {
+        serverLogger.error("Error initializing PostgreSQL database:", err)
+        throw err
+      }
+    },
+
+    async storeMessages(messages) {
+      if (!pool) throw new Error("Database not initialized")
+      if (messages.length === 0) return
+      const client = await pool.connect()
+      try {
+        await client.query("BEGIN")
+        for (const msg of messages) {
+          await client.query(
+            `INSERT INTO channel_messages (id, channel, message, instance_id, timestamp, metadata) VALUES ($1, $2, $3, $4, $5, $6)`,
+            [msg.id, msg.channel, msg.message, msg.instanceId, msg.timestamp, msg.metadata || null]
+          )
+        }
+        await client.query("COMMIT")
+      } catch (err) { await client.query("ROLLBACK"); throw err }
+      finally { client.release() }
+    },
+
+    async getMessages(channel, since, limit = 50) {
+      if (!pool) throw new Error("Database not initialized")
+      let query = "SELECT * FROM channel_messages WHERE channel = $1"
+      const params = [channel]
+      let paramIndex = 2
+      if (since !== undefined) {
+        if (typeof since === "number") {
+          query += ` AND timestamp > $${paramIndex}`
+          params.push(since)
+          paramIndex++
+        } else {
+          const timestampResult = await pool.query("SELECT timestamp FROM channel_messages WHERE id = $1", [since])
+          const timestamp = timestampResult.rows[0]?.timestamp || 0
+          query += ` AND timestamp > $${paramIndex}`
+          params.push(timestamp)
+          paramIndex++
+        }
+      }
+      query += ` ORDER BY timestamp ASC LIMIT $${paramIndex}`
+      params.push(limit)
+      const result = await pool.query(query, params)
+      return result.rows.map((row) => ({
+        id: row.id, channel: row.channel, message: row.message,
+        instanceId: row.instance_id, timestamp: parseInt(row.timestamp), metadata: row.metadata,
+      }))
+    },
+
+    async storeRecords(records) {
+      if (!pool) throw new Error("Database not initialized")
+      if (records.length === 0) return
+      const client = await pool.connect()
+      try {
+        await client.query("BEGIN")
+        for (const record of records) {
+          await client.query(
+            `INSERT INTO records (record_id, version, value, timestamp) VALUES ($1, $2, $3, $4)
+             ON CONFLICT (record_id) DO UPDATE SET version = $2, value = $3, timestamp = $4`,
+            [record.recordId, record.version, record.value, record.timestamp]
+          )
+        }
+        await client.query("COMMIT")
+      } catch (err) { await client.query("ROLLBACK"); throw err }
+      finally { client.release() }
+    },
+
+    async getRecords(pattern) {
+      if (!pool) throw new Error("Database not initialized")
+      const sqlPattern = convertToSqlPattern(pattern)
+      const result = await pool.query(
+        `SELECT record_id, version, value, timestamp FROM records WHERE record_id LIKE $1 ORDER BY timestamp DESC`,
+        [sqlPattern]
+      )
+      return result.rows.map((row) => ({
+        recordId: row.record_id, version: row.version,
+        value: row.value, timestamp: parseInt(row.timestamp),
+      }))
+    },
+
+    async close() {
+      if (!pool) return
+      await pool.end()
+      pool = null
+      initialized = false
+    },
+  }
+}

package/src/adapters/sqlite.js

@@ -0,0 +1,177 @@
+import { convertToSqlPattern } from "../server/utils/pattern-conversion.js"
+import { serverLogger } from "../shared/index.js"
+
+export function createSqliteAdapter(options = {}) {
+  const opts = { filename: ":memory:", ...options }
+  let db = null
+  let initialized = false
+
+  async function createTables() {
+    if (!db) throw new Error("Database not initialized")
+    return new Promise((resolve, reject) => {
+      db.run(
+        `CREATE TABLE IF NOT EXISTS channel_messages (
+          id TEXT PRIMARY KEY,
+          channel TEXT NOT NULL,
+          message TEXT NOT NULL,
+          instance_id TEXT NOT NULL,
+          timestamp INTEGER NOT NULL,
+          metadata TEXT
+        )`,
+        (err) => {
+          if (err) return reject(err)
+          db.run("CREATE INDEX IF NOT EXISTS idx_channel_timestamp ON channel_messages (channel, timestamp)", (err) => {
+            if (err) return reject(err)
+            db.run(
+              `CREATE TABLE IF NOT EXISTS records (
+                record_id TEXT PRIMARY KEY,
+                version INTEGER NOT NULL,
+                value TEXT NOT NULL,
+                timestamp INTEGER NOT NULL
+              )`,
+              (err) => {
+                if (err) return reject(err)
+                db.run("CREATE INDEX IF NOT EXISTS idx_records_timestamp ON records (timestamp)", (err) => {
+                  if (err) return reject(err)
+                  resolve()
+                })
+              }
+            )
+          })
+        }
+      )
+    })
+  }
+
+  return {
+    async initialize() {
+      if (initialized) return
+      const sqlite3 = await import("sqlite3")
+      const { Database } = sqlite3.default || sqlite3
+      return new Promise((resolve, reject) => {
+        try {
+          db = new Database(opts.filename, async (err) => {
+            if (err) return reject(err)
+            try {
+              await createTables()
+              initialized = true
+              resolve()
+            } catch (e) { reject(e) }
+          })
+        } catch (err) { reject(err) }
+      })
+    },
+
+    async storeMessages(messages) {
+      if (!db) throw new Error("Database not initialized")
+      if (messages.length === 0) return
+      return new Promise((resolve, reject) => {
+        db.serialize(() => {
+          db.run("BEGIN TRANSACTION")
+          const stmt = db.prepare(
+            `INSERT INTO channel_messages (id, channel, message, instance_id, timestamp, metadata) VALUES (?, ?, ?, ?, ?, ?)`
+          )
+          try {
+            for (const msg of messages) {
+              const metadata = msg.metadata ? JSON.stringify(msg.metadata) : null
+              stmt.run(msg.id, msg.channel, msg.message, msg.instanceId, msg.timestamp, metadata)
+            }
+            stmt.finalize()
+            db.run("COMMIT", (err) => { if (err) reject(err); else resolve() })
+          } catch (err) { db.run("ROLLBACK"); reject(err) }
+        })
+      })
+    },
+
+    async getMessages(channel, since, limit = 50) {
+      if (!db) throw new Error("Database not initialized")
+      let query = "SELECT * FROM channel_messages WHERE channel = ?"
+      const params = [channel]
+      if (since !== undefined) {
+        if (typeof since === "number") {
+          query += " AND timestamp > ?"
+          params.push(since)
+        } else {
+          const timestampQuery = await new Promise((resolve, reject) => {
+            db.get("SELECT timestamp FROM channel_messages WHERE id = ?", [since], (err, row) => {
+              if (err) reject(err)
+              else resolve(row ? row.timestamp : 0)
+            })
+          })
+          query += " AND timestamp > ?"
+          params.push(timestampQuery)
+        }
+      }
+      query += " ORDER BY timestamp ASC LIMIT ?"
+      params.push(limit)
+      return new Promise((resolve, reject) => {
+        db.all(query, params, (err, rows) => {
+          if (err) return reject(err)
+          resolve(rows.map((row) => ({
+            id: row.id,
+            channel: row.channel,
+            message: row.message,
+            instanceId: row.instance_id,
+            timestamp: row.timestamp,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+          })))
+        })
+      })
+    },
+
+    async storeRecords(records) {
+      if (!db) throw new Error("Database not initialized")
+      if (records.length === 0) return
+      return new Promise((resolve, reject) => {
+        db.serialize(() => {
+          db.run("BEGIN TRANSACTION")
+          const stmt = db.prepare(
+            `INSERT OR REPLACE INTO records (record_id, version, value, timestamp) VALUES (?, ?, ?, ?)`
+          )
+          try {
+            for (const record of records) {
+              stmt.run(record.recordId, record.version, record.value, record.timestamp)
+            }
+            stmt.finalize()
+            db.run("COMMIT", (err) => {
+              if (err) { db.run("ROLLBACK"); reject(err) }
+              else resolve()
+            })
+          } catch (err) { db.run("ROLLBACK"); reject(err) }
+        })
+      })
+    },
+
+    async getRecords(pattern) {
+      if (!db) throw new Error("Database not initialized")
+      const sqlPattern = convertToSqlPattern(pattern)
+      return new Promise((resolve, reject) => {
+        db.all(
+          `SELECT record_id, version, value, timestamp FROM records WHERE record_id LIKE ? ORDER BY timestamp DESC`,
+          [sqlPattern],
+          (err, rows) => {
+            if (err) return reject(err)
+            resolve(rows.map((row) => ({
+              recordId: row.record_id,
+              version: row.version,
+              value: row.value,
+              timestamp: row.timestamp,
+            })))
+          }
+        )
+      })
+    },
+
+    async close() {
+      if (!db) return
+      return new Promise((resolve, reject) => {
+        db.close((err) => {
+          if (err) return reject(err)
+          db = null
+          initialized = false
+          resolve()
+        })
+      })
+    },
+  }
+}