@weft-js/start 0.1.0 → 0.1.2

package/src/socket/publish.ts

@@ -0,0 +1,56 @@
+import type { PublishOptions } from '../channel'
+import { stable, StartError, type Fn } from '../data'
+import { hub } from '../hub'
+import { check } from './check'
+
+const roomName = (id: string, params: unknown) => `weft:c:${id}:${stable(params)}`
+
+/** `room.publish` and `room.in(params).publish`. */
+export async function publish(
+  fn: Fn,
+  params: unknown,
+  name: string,
+  message: unknown,
+  o: PublishOptions & { from?: string } = {},
+) {
+  const h = hub()
+  const valid = await check(
+    fn.kind === 'shared' ? fn.def.key : fn.def.params,
+    params,
+    `\`${fn.$id}\`'s params`,
+  )
+  if (h.dev) {
+    const schema = Object.hasOwn(fn.def.server ?? {}, name) ? fn.def.server![name] : undefined
+    if (!schema)
+      throw new StartError(
+        'C002',
+        `\`${fn.$id}\` has no server message \`${name}\``,
+        'add it to `server`',
+        { status: 500 },
+      )
+    const r = await schema['~standard'].validate(message)
+    if (r.issues)
+      throw new StartError(
+        'C002',
+        `\`${fn.$id}.${name}\` was published with a message its schema rejects: ${r.issues.map((i) => i.message).join('; ')}`,
+        'fix the message, or the schema',
+        { status: 500 },
+      )
+  }
+  // `v` first: the hub reads it off the front of the string, to leave the ring alone.
+  const raw = JSON.stringify({
+    ...(o.volatile && { v: 1 }),
+    ...(o.from && { f: o.from }),
+    ...(o.exceptSelf && { x: 1 }),
+    ...(o.to && { t: o.to }),
+    n: name,
+    m: message,
+  })
+  if (raw.length > h.limits.message)
+    throw new StartError(
+      'R008',
+      `a \`${fn.$id}\` message is ${raw.length} bytes; a message may be ${h.limits.message}`,
+      'publish less, or an id subscribers fetch',
+    )
+  await h.bus.publish(roomName(fn.$id, valid), raw)
+}

package/src/socket/rooms.ts

@@ -0,0 +1,41 @@
+import type { Hub, Ev } from '../hub'
+import type { Hubbed, Room, Value } from './types'
+
+export const VALUE = '$v',
+  ASK = '$?'
+const VALUES = 10_000
+
+export function room(h: Hub, st: Hubbed, name: string, shared: boolean): Room {
+  let r = st.rooms.get(name)
+  if (r) return (r.refs++, r)
+  const ch = h.channel(name)
+  const on = (ev: Ev | null) => {
+    if (!ev || !shared) return
+    const m = (ev.p ??= JSON.parse(ev.raw)) as { n: string; m: never }
+    if (m.n === VALUE) store(st, name, m.m)
+    else if (m.n === ASK) {
+      const v = st.values.get(name)
+      if (v) void h.bus.publish(name, JSON.stringify({ n: VALUE, m: v }))
+    }
+  }
+  ch.listeners.add(on)
+  r = { name, ch, refs: 1, shared, on }
+  st.rooms.set(name, r)
+  if (shared && !st.values.has(name))
+    void ch.ready.then(() => h.bus.publish(name, JSON.stringify({ n: ASK })))
+  return r
+}
+
+export function leaveRoom(h: Hub, st: Hubbed, r: Room) {
+  if (--r.refs) return
+  st.rooms.delete(r.name)
+  h.unlisten(r.ch, r.on)
+}
+
+export function store(st: Hubbed, name: string, v: Value) {
+  const had = st.values.get(name)
+  if (had && (had.at > v.at || (had.at === v.at && had.o >= v.o))) return
+  st.values.delete(name) // last in the map: the oldest key goes first
+  st.values.set(name, v)
+  if (st.values.size > VALUES) st.values.delete(st.values.keys().next().value!)
+}

package/src/socket/route.ts

@@ -0,0 +1,79 @@
+import { checkOrigins } from '../hub'
+import type { Scope } from '../exec'
+import type { Peer, Attached } from '../socket'
+
+interface WsPeer {
+  id: string
+  send(text: string): unknown
+  close(code?: number, reason?: string): unknown
+  websocket?: { bufferedAmount?: number }
+}
+
+/** Nitro reads `crossws` off the response (research 32 §1). A refusal is a hook that throws, so no socket opens. */
+export function socketRouteWith(
+  request: Request,
+  scope: Scope,
+  origins: string[],
+  attach: (peer: Peer, request: Request, scope: Scope) => Promise<Attached>,
+): Promise<Response> {
+  const hooks = (crossws: object) =>
+    Promise.resolve(Object.assign(new Response('Upgrade required', { status: 426 }), { crossws }))
+  const turnAway = (code: string, message: string, status: number) => {
+    scope.options.onDiagnostic?.({ code, severity: 'error', message })
+    // oxlint-disable only-throw-error -- crossws answers an upgrade with the Response its hook throws
+    return hooks({
+      upgrade() {
+        throw new Response(message, { status }) /* oxlint-enable only-throw-error */
+      },
+    })
+  }
+  if (request.headers.get('upgrade')?.toLowerCase() !== 'websocket')
+    return Promise.resolve(
+      new Response('Upgrade required', { status: 426, headers: { 'cache-control': 'no-store' } }),
+    )
+  try {
+    checkOrigins(origins)
+  } catch (e) {
+    return turnAway('R004', (e as Error).message, 500)
+  }
+  const origin = request.headers.get('origin')
+  if (!origin || (origin !== new URL(request.url).origin && !origins.includes(origin)))
+    return turnAway(
+      'R010',
+      `R010: origin \`${origin ?? 'none'}\` may not open a socket: list it in \`realtime({ origins })\``,
+      403,
+    )
+  const peers = new Map<string, Promise<Pick<Attached, 'message' | 'close'>>>()
+  const mux = new URL(request.url).searchParams.has('mux')
+  return hooks({
+    open(peer: WsPeer) {
+      const p: Peer = {
+        send: (t) => void peer.send(t),
+        close: (code, reason) => peer.close(code, reason),
+        backlog: () => peer.websocket?.bufferedAmount ?? 0,
+      }
+      peers.set(
+        peer.id,
+        (mux
+          ? import('../mux').then((m) => m.muxed(p, request, scope))
+          : attach(p, request, scope)
+        ).catch((e) => {
+          scope.options.onDiagnostic?.({
+            code: 'E_RT',
+            severity: 'error',
+            message: `/_weft/ws: ${e instanceof Error ? (e.stack ?? e.message) : String(e)}`,
+          })
+          peer.close(1011, 'context failed')
+          return { message() {}, close() {} }
+        }),
+      )
+    },
+    message(peer: WsPeer, m: { text(): string }) {
+      void peers.get(peer.id)?.then((a) => a.message(m.text()))
+    },
+    close(peer: WsPeer) {
+      void peers.get(peer.id)?.then((a) => a.close())
+      peers.delete(peer.id)
+    },
+  })
+}

package/src/socket/shared.ts

@@ -0,0 +1,26 @@
+import type { Fn } from '../data'
+import { stable } from '../data'
+import { hub, type Hub } from '../hub'
+import { check } from './check'
+import { store, VALUE } from './rooms'
+import type { Hubbed, Value } from './types'
+
+const roomName = (id: string, params: unknown) => `weft:c:${id}:${stable(params)}`
+
+export function sharedWriter(stateOf: (h: Hub) => Hubbed) {
+  /** A shared value written by the server: `deckSlide.in(key).set(3)`. */
+  return async function setShared(fn: Fn, key: unknown, value: unknown) {
+    const h = hub()
+    const valid = await check(fn.def.key, key, `\`${fn.$id}\`'s key`)
+    const v = await check(fn.def.value, value, `\`${fn.$id}\`'s value`)
+    const st = stateOf(h),
+      name = roomName(fn.$id, valid)
+    const stamp: Value = {
+      v,
+      at: Math.max(Date.now(), (st.values.get(name)?.at ?? 0) + 1),
+      o: h.epoch,
+    }
+    store(st, name, stamp)
+    await h.bus.publish(name, JSON.stringify({ n: VALUE, m: stamp }))
+  }
+}

package/src/socket/types.ts

@@ -0,0 +1,48 @@
+import type { Context, Fn } from '../data'
+import type { ScopeOptions } from '../exec'
+import type { Channel, Ev } from '../hub'
+import type { Peer } from '../socket'
+
+export interface Join {
+  n: number
+  fn: Fn
+  params: unknown
+  room?: Room
+  on?: (ev: Ev | null) => void
+  bucket: Bucket
+  gone?: boolean
+  chain: Promise<unknown>
+}
+export interface Bucket {
+  tokens: number
+  at: number
+}
+export interface Sock {
+  k: string
+  peer: Peer
+  request: Request
+  options: ScopeOptions
+  ctx: Context
+  user?: string | undefined
+  joins: Map<number, Join>
+  bucket: Bucket
+  last: number
+  timers: ReturnType<typeof setTimeout>[]
+}
+export interface Room {
+  name: string
+  ch: Channel
+  refs: number
+  shared: boolean
+  on: (ev: Ev | null) => void
+}
+export interface Value {
+  v: unknown
+  at: number
+  o: string
+}
+export interface Hubbed {
+  socks: Set<Sock>
+  rooms: Map<string, Room>
+  values: Map<string, Value>
+}