@scp-dev/broker 0.0.0-stage → 0.1.0

package/src/socket.ts

@@ -0,0 +1,57 @@
+import type { Socket } from "node:net"
+
+export interface ConnHandlers<T> {
+  data(conn: Conn<T>, chunk: Buffer): void
+  drain(conn: Conn<T>): void
+  close(conn: Conn<T>, error?: Error): void
+}
+
+/** how long an ended connection waits for its peer to close before it is cut */
+const END_GRACE_MS = 2000
+
+/** a unix socket connection with per-connection state, writing through LineWriter's partial-write contract */
+export class Conn<T> {
+  private ending = false
+
+  constructor(
+    readonly socket: Socket,
+    public data: T,
+    handlers: ConnHandlers<T>,
+  ) {
+    socket.on("data", (chunk: Buffer) => {
+      if (!this.ending) handlers.data(this, chunk)
+    })
+    socket.on("drain", () => handlers.drain(this))
+    socket.on("error", (error) => handlers.close(this, error))
+    socket.on("close", () => handlers.close(this))
+  }
+
+  /** bytes the socket took but has not sent yet */
+  get unsent(): number {
+    return this.socket.writableLength
+  }
+
+  /** takes all of `bytes`, or none while the socket waits to drain */
+  write(bytes: Uint8Array): number {
+    if (this.ending || this.socket.destroyed || this.socket.writableNeedDrain) return 0
+    this.socket.write(bytes)
+    return bytes.length
+  }
+
+  /** sends what was written, then closes once the peer does, or after a grace period; what the peer still sends is discarded */
+  end(): void {
+    if (this.ending || this.socket.destroyed) return
+    this.ending = true
+    this.socket.resume()
+    this.socket.end()
+    setTimeout(() => this.socket.destroy(), END_GRACE_MS).unref()
+  }
+
+  pause(): void {
+    if (!this.ending) this.socket.pause()
+  }
+
+  resume(): void {
+    this.socket.resume()
+  }
+}

package/src/sqlite.ts

@@ -0,0 +1,90 @@
+import { createRequire } from "node:module"
+import type { Sql, SqlValue } from "@scp-dev/core"
+
+/** the broker's SQLite file: bun:sqlite under Bun, node:sqlite under Node, each loaded only by its own runtime */
+export interface Database extends Sql {
+  /** statements that bind nothing, such as pragmas */
+  exec(statement: string): void
+  /** runs `fn` in one IMMEDIATE transaction; a call inside one is a savepoint */
+  transaction<T>(fn: () => T): T
+  close(): void
+}
+
+interface Driver {
+  exec(statement: string): void
+  all(query: string, params: SqlValue[]): unknown[]
+  close(): void
+}
+
+const STATEMENT_CACHE = 512
+
+/** a require that bundlers leave alone, so neither runtime resolves the other's module, and node:sqlite keeps its prefix */
+const load = createRequire(import.meta.url)
+
+function bunDriver(path: string): Driver {
+  const { Database } = load("bun:sqlite") as typeof import("bun:sqlite")
+  const db = new Database(path, { create: true })
+  return {
+    exec: (statement) => void db.run(statement),
+    all: (query, params) => db.query(query).all(...params),
+    close: () => db.close(),
+  }
+}
+
+function nodeDriver(path: string): Driver {
+  const { DatabaseSync } = load("node:sqlite") as typeof import("node:sqlite")
+  const db = new DatabaseSync(path)
+  const statements = new Map<string, ReturnType<typeof db.prepare>>()
+  return {
+    exec: (statement) => db.exec(statement),
+    all: (query, params) => {
+      let statement = statements.get(query)
+      if (!statement) {
+        if (statements.size >= STATEMENT_CACHE) statements.clear()
+        statement = db.prepare(query)
+        statements.set(query, statement)
+      }
+      return statement.all(...params)
+    },
+    close: () => db.close(),
+  }
+}
+
+export function openDatabase(path: string): Database {
+  const driver = typeof process.versions.bun === "string" ? bunDriver(path) : nodeDriver(path)
+  let depth = 0
+  return {
+    exec: (statement) => driver.exec(statement),
+    all: <T>(query: string, ...params: SqlValue[]) => driver.all(query, params) as T[],
+    close: () => driver.close(),
+    transaction<T>(fn: () => T): T {
+      const savepoint = depth ? `tx_${depth}` : undefined
+      driver.exec(savepoint ? `SAVEPOINT ${savepoint}` : "BEGIN IMMEDIATE")
+      depth++
+      let result: T
+      try {
+        result = fn()
+      } catch (error) {
+        depth--
+        try {
+          if (savepoint) {
+            driver.exec(`ROLLBACK TO ${savepoint}`)
+            driver.exec(`RELEASE ${savepoint}`)
+          } else driver.exec("ROLLBACK")
+        } catch {}
+        throw error
+      }
+      depth--
+      try {
+        driver.exec(savepoint ? `RELEASE ${savepoint}` : "COMMIT")
+      } catch (error) {
+        if (!savepoint)
+          try {
+            driver.exec("ROLLBACK")
+          } catch {}
+        throw error
+      }
+      return result
+    },
+  }
+}

package/src/testing.ts

@@ -0,0 +1,168 @@
+import { Database } from "bun:sqlite"
+import type { Server, ServerWebSocket } from "bun"
+import { type CrossAccountLink, PASS_GATE, sha256Hex, type Sql, type SqlValue, type XContact } from "@scp-dev/core"
+import { type HubGrant, type HubSocket, RelayHub } from "@scp-dev/hub"
+
+export interface FakeToken {
+  tokenId: string
+  /** the account handle the token acts as */
+  user: string
+}
+
+export interface FakeHubServer {
+  /** the http origin, as a bridge's url takes it */
+  url: string
+  hub(account: string): RelayHub
+  /** closes every socket of `machine` (code 1012), as a dropped network would */
+  drop(account: string, machine: string): void
+  /** the next frame calling `method` from `machine` closes its socket instead of reaching the hub; resolves once it did */
+  dropOn(account: string, machine: string, method: string): Promise<void>
+  /** the open sockets of an account, with their state */
+  sockets(account: string): HubSocket[]
+  stop(): Promise<void>
+}
+
+type Data = { account: string; grant: HubGrant; socket?: HubSocket }
+
+interface Account {
+  hub: RelayHub
+  sockets: Map<ServerWebSocket<Data>, HubSocket>
+  traps: Map<string, { method: string; fired: () => void }>
+}
+
+/**
+ * a stand-in for a hosted hub's /v1/relay routes: one RelayHub per account over bun:sqlite, bearer credentials from a table; `contacts` pairs
+ * account handles that are active contacts both ways (default allowlist: every root), their relays linked directly
+ */
+export function startFakeHubServer(options: {
+  tokens: Record<string, FakeToken>
+  now?: (() => number) | undefined
+  contacts?: [string, string][] | undefined
+}): FakeHubServer {
+  const accounts = new Map<string, Account>()
+
+  function linkOf(name: string): CrossAccountLink {
+    const peers = () => (options.contacts ?? []).flatMap(([a, b]) => (a === name ? [b] : b === name ? [a] : []))
+    const contact = (peer: string): XContact => ({
+      peerId: `usr_${peer}`,
+      peerHandle: peer,
+      allow: [{ machine: "*", sel: "tree:root" }],
+      dir: "both",
+      limits: null,
+    })
+    return {
+      self: { id: `usr_${name}`, handle: name },
+      contactByHandle: async (handle) => (peers().includes(handle) ? contact(handle) : null),
+      contactById: async (id) => (id.startsWith("usr_") && peers().includes(id.slice(4)) ? contact(id.slice(4)) : null),
+      contacts: async () => peers().map(contact),
+      deliver: async (peer, msg) => account(peer.peerHandle).hub.xreceive(`usr_${name}`, JSON.parse(JSON.stringify(msg))),
+      list: async (peer) => account(peer.peerHandle).hub.xlist(`usr_${name}`),
+      gate: PASS_GATE,
+    }
+  }
+
+  function account(name: string): Account {
+    let found = accounts.get(name)
+    if (found) return found
+    const db = new Database(":memory:")
+    const sql: Sql = { all: <T>(query: string, ...params: SqlValue[]) => db.query(query).all(...params) as T[] }
+    const sockets = new Map<ServerWebSocket<Data>, HubSocket>()
+    const hub = new RelayHub({
+      sql,
+      hash: sha256Hex,
+      transaction: (fn) => db.transaction(fn)(),
+      ...(options.now ? { now: options.now } : {}),
+      sockets: () => [...sockets.values()],
+      save: () => {},
+      ...(options.contacts ? { crossAccount: linkOf(name) } : {}),
+    })
+    hub.init({ user: name })
+    found = { hub, sockets, traps: new Map() }
+    accounts.set(name, found)
+    return found
+  }
+
+  function grantOf(request: Request): { account: string; grant: HubGrant } | null {
+    const match = /^Bearer (\S+)$/.exec(request.headers.get("authorization") ?? "")
+    const token = match ? options.tokens[match[1]!] : undefined
+    if (!token) return null
+    return {
+      account: token.user,
+      grant: { tokenId: token.tokenId, userId: `usr_${token.user}`, actorId: null, expiresAt: Date.now() + 3_600_000, scoped: false, role: null },
+    }
+  }
+
+  const server: Server<Data> = Bun.serve<Data>({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(request, srv) {
+      const path = new URL(request.url).pathname
+      if (path !== "/v1/relay/ws" && path !== "/v1/relay/rpc") return Response.json({ error: "not_found" }, { status: 404 })
+      const principal = grantOf(request)
+      if (!principal) return Response.json({ error: "unauthorized" }, { status: 401 })
+      const { hub } = account(principal.account)
+      if (path === "/v1/relay/ws") {
+        if (hub.full()) return Response.json({ error: "too_many_sockets" }, { status: 429 })
+        if (srv.upgrade(request, { data: principal })) return undefined
+        return Response.json({ error: "upgrade_required" }, { status: 426 })
+      }
+      if (request.method !== "POST") return Response.json({ error: "not_found" }, { status: 404 })
+      let body: unknown
+      try {
+        body = JSON.parse(await request.text())
+      } catch {
+        return Response.json({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } })
+      }
+      return Response.json(await hub.batch(principal.grant, body))
+    },
+    websocket: {
+      open(ws) {
+        const state = account(ws.data.account)
+        const socket: HubSocket = {
+          conn: RelayHub.connection(ws.data.grant),
+          send: (text) => void ws.send(text),
+          close: (code, reason) => ws.close(code, reason),
+        }
+        ws.data.socket = socket
+        state.sockets.set(ws, socket)
+      },
+      async message(ws, message) {
+        const state = account(ws.data.account)
+        const socket = ws.data.socket!
+        const text = typeof message === "string" ? message : new TextDecoder().decode(message)
+        const machine = socket.conn.machine
+        if (machine && state.traps.size) {
+          const method = (JSON.parse(text) as { method?: string }).method
+          const trap = state.traps.get(machine)
+          if (method && trap?.method === method) {
+            state.traps.delete(machine)
+            ws.close(1012, "dropped by the test")
+            trap.fired()
+            return
+          }
+        }
+        await state.hub.message(socket, text)
+      },
+      close(ws) {
+        const state = account(ws.data.account)
+        state.sockets.delete(ws)
+        if (ws.data.socket) state.hub.closed(ws.data.socket)
+      },
+    },
+  })
+
+  return {
+    url: `http://127.0.0.1:${server.port}`,
+    hub: (name) => account(name).hub,
+    drop(name, machine) {
+      for (const [ws, socket] of account(name).sockets) if (socket.conn.machine === machine) ws.close(1012, "dropped by the test")
+    },
+    dropOn(name, machine, method) {
+      return new Promise((fired) => account(name).traps.set(machine, { method, fired }))
+    },
+    sockets: (name) => [...account(name).sockets.values()],
+    async stop() {
+      await server.stop(true)
+    },
+  }
+}