wenay-common2 1.0.69 → 1.0.73

package/replay/peer-sdk.test.ts

@@ -0,0 +1,228 @@
+// Acceptance oracle for the Peer SDK (library-uplift-tasks task 2): the happy
+// path "two accounts see each other's store and can promote to direct" in ~10
+// user lines, over a real Socket.IO/RPC wire, NEXT TO legacy rpc keys on the
+// same connection. Direct = fake WebRTC runtime (injected factory, as designed).
+import express from 'express'
+import {createServer} from 'http'
+import type {AddressInfo} from 'net'
+import {Server as SocketIOServer} from 'socket.io'
+import {io} from 'socket.io-client'
+import {listen as createListenPair} from '../src/Common/events/Listen'
+import {RtcDataChannel, RtcPeerConnection} from '../src/Common/events/replay-index'
+import {flushReactive} from '../src/Common/Observe/reactive'
+import {createPeerClient, createPeerHost} from '../src/Common/peer/peer-index'
+import {createRpcClientHub} from '../src/Common/rcp/rpc-clientHub'
+import {createRpcServerAuto} from '../src/Common/rcp/rpc-server-auto'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+const delay = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+const json = (v: any) => JSON.stringify(v)
+
+async function waitFor(label: string, cond: () => boolean) {
+    for (let i = 0; i < 200; i++) {
+        if (cond()) return
+        await delay(20)
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+// ============ fake in-proc WebRTC runtime (same shape as route-webrtc oracle) ============
+function createFakeRtcNet() {
+    let n = 0
+    const pcs = new Map<string, any>()
+    const stats = {ice: 0, channels: 0}
+    function makeDcPair(): [RtcDataChannel, RtcDataChannel] {
+        let closed = false
+        function side(other: () => any): any {
+            const me: any = {onopen: null, onmessage: null, onclose: null, onerror: null}
+            me.send = (data: string) => { if (!closed) setTimeout(function deliverDc() { if (!closed) other().onmessage?.({data}) }, 0) }
+            me.close = () => {
+                if (closed) return
+                closed = true
+                setTimeout(function closeDc() { me.onclose?.(); other().onclose?.() }, 0)
+            }
+            return me
+        }
+        let a: any, b: any
+        a = side(() => b)
+        b = side(() => a)
+        return [a, b]
+    }
+    function tryConnect(me: any) {
+        if (!me.local || !me.remote) return
+        const other = pcs.get(me.remote.sdp)
+        if (!other || !other.local || !other.remote || other.remote.sdp != me.id) return
+        const initiator = me.pendingDcs.length ? me : other
+        const responder = initiator == me ? other : me
+        if (!initiator.pendingDcs.length || initiator.linked) return
+        initiator.linked = responder.linked = true
+        for (const dc of initiator.pendingDcs) {
+            const [a, b] = makeDcPair()
+            dc.attach(a)
+            stats.channels++
+            setTimeout(function announceChannel() {
+                responder.pc.ondatachannel?.({channel: b})
+                dc.fireOpen()
+            }, 0)
+        }
+        initiator.pendingDcs = []
+    }
+    function pc(): RtcPeerConnection {
+        const id = 'sdp-' + (++n)
+        const me: any = {id, local: null, remote: null, pendingDcs: [], linked: false}
+        const api: RtcPeerConnection = {
+            createDataChannel() {
+                let real: any = null
+                const shell: any = {onopen: null, onmessage: null, onclose: null, onerror: null}
+                shell.send = (data: string) => real?.send(data)
+                shell.close = () => real?.close()
+                me.pendingDcs.push({
+                    attach(a: any) {
+                        real = a
+                        if (!a) return
+                        a.onmessage = (ev: any) => shell.onmessage?.(ev)
+                        a.onclose = () => shell.onclose?.()
+                    },
+                    fireOpen() { shell.onopen?.() },
+                })
+                return shell
+            },
+            createOffer: async () => ({type: 'offer', sdp: id}),
+            createAnswer: async () => ({type: 'answer', sdp: id}),
+            setLocalDescription(d) {
+                me.local = d
+                setTimeout(function trickleIce() { api.onicecandidate?.({candidate: {via: id}}) }, 0)
+            },
+            setRemoteDescription(d) { me.remote = d; tryConnect(me) },
+            addIceCandidate() { stats.ice++ },
+            close() { me.pendingDcs = [] },
+            onicecandidate: null,
+            ondatachannel: null,
+        }
+        me.pc = api
+        pcs.set(id, me)
+        return api
+    }
+    return {pc, stats}
+}
+
+type World = {cursor: {x: number, y: number}, name?: string}
+
+async function main() {
+    console.log('\n[peer-sdk] two accounts, real socket, legacy keys alongside')
+
+    const rtcNet = createFakeRtcNet()
+
+    // ================= SERVER: legacy object + peer fragment =================
+    const host = createPeerHost()
+    const app = express()
+    const httpServer = createServer(app)
+    const ioServer = new SocketIOServer(httpServer)
+    ioServer.on('connection', socket => {
+        const account = String(socket.handshake.auth?.account)
+        const peer = host.connection(account)
+        const [disconnect, disconnectListen] = createListenPair<[]>()
+        socket.on('disconnect', () => { disconnect(); peer.close() })
+        createRpcServerAuto({
+            socket: {emit: (key, data) => socket.emit(key, data), on: (key, cb) => socket.on(key, cb)},
+            socketKey: 'app',
+            object: {
+                legacyHello: (name: string) => 'hello ' + name, // старый код живёт рядом, нетронутый
+                peer: peer.fragment,
+            },
+            disconnectListen,
+        })
+    })
+    await new Promise<void>((resolve, reject) => {
+        httpServer.once('error', reject)
+        httpServer.listen(0, '127.0.0.1', resolve)
+    })
+    const port = (httpServer.address() as AddressInfo).port
+
+    async function connect(account: string) {
+        const hub = createRpcClientHub(
+            () => io(`http://127.0.0.1:${port}`, {transports: ['websocket'], forceNew: true, auth: {account}}),
+            r => ({api: r<any>('app')}) as const,
+        )
+        const clients = await hub.setToken(null)
+        await clients.api.readyStrict()
+        return {func: clients.api.func, closeSocket: () => hub.socket?.disconnect?.()}
+    }
+
+    // ================= CLIENTS: the happy path =================
+    const connA = await connect('a')
+    const connB = await connect('b')
+    const a = createPeerClient<World>({
+        remote: connA.func.peer, account: 'a',
+        initial: {cursor: {x: 0, y: 0}, name: 'alice'},
+        rtc: rtcNet.pc, drain: 'micro',
+    })
+    const b = createPeerClient<World>({
+        remote: connB.func.peer, account: 'b',
+        initial: {cursor: {x: 100, y: 100}, name: 'bob'},
+        rtc: rtcNet.pc, drain: 'micro',
+    })
+    const aSeenByB = b.peer('a')
+    const bSeenByA = a.peer('b')
+    await Promise.all([aSeenByB.ready, bSeenByA.ready])
+    // ^^^ вся клиентская сторона happy path: connect + createPeerClient + peer()
+
+    ok(await connA.func.legacyHello('world') == 'hello world', 'legacy rpc key works untouched on the same connection')
+    await waitFor('initial mirrors', () => json(aSeenByB.store.state) == json(a.store.snapshot())
+        && json(bSeenByA.store.state) == json(b.store.snapshot()))
+    ok(true, 'b mirrors a via relay, a mirrors b symmetrically')
+
+    a.store.state.cursor.x = 5
+    await flushReactive(a.store.state)
+    await waitFor('relay live patch', () => aSeenByB.store.state.cursor.x == 5)
+    ok(aSeenByB.route() == 'relay', 'live updates flow while the route is relay')
+
+    // ================= direct promotion =================
+    const seqBefore = aSeenByB.seq()
+    const res = await aSeenByB.promoteDirect()
+    ok(res.ok && aSeenByB.route() == 'direct', 'b -> a promoted to direct via webrtc signaling')
+    a.store.state.cursor.y = 7
+    a.store.state.name = 'alice!'
+    await flushReactive(a.store.state)
+    await waitFor('direct live patch', () => aSeenByB.store.state.cursor.y == 7 && aSeenByB.store.state.name == 'alice!')
+    ok(json(aSeenByB.store.state) == json(a.store.snapshot()), 'mirror converged over the direct channel')
+    ok(aSeenByB.seq() > seqBefore, `same seq space across the hand-off: ${seqBefore} -> ${aSeenByB.seq()} (no keyframe reset)`)
+    ok(bSeenByA.route() == 'relay', 'the other direction is independent and still on relay')
+
+    // ================= server revoke -> relay fallback =================
+    host.revoke('a|b', ['a', 'b'], 'policy change')
+    await waitFor('revoke fallback', () => aSeenByB.state() == 'fallback')
+    a.store.state.cursor.x = 9
+    await flushReactive(a.store.state)
+    await waitFor('relay resume after revoke', () => aSeenByB.store.state.cursor.x == 9)
+    ok(json(aSeenByB.store.state) == json(a.store.snapshot()), 'server revoke: mirror keeps converging via relay, no gap')
+
+    // ================= late joiner: relay keyframe without the owner republishing =================
+    const connC = await connect('c')
+    const c = createPeerClient<World>({
+        remote: connC.func.peer, account: 'c',
+        initial: {cursor: {x: -1, y: -1}}, drain: 'micro', // relay-only: без rtc
+    })
+    const aSeenByC = c.peer('a')
+    await aSeenByC.ready
+    ok(json(aSeenByC.store.state) == json(a.store.snapshot()), 'late joiner gets the folded keyframe from the relay journal')
+    let directDenied = false
+    try { await c.peer('b').promoteDirect() } catch { directDenied = true }
+    ok(directDenied, 'relay-only client (no rtc factory) refuses promoteDirect loudly')
+
+    // ================= teardown =================
+    a.close(); b.close(); c.close()
+    connA.closeSocket(); connB.closeSocket(); connC.closeSocket()
+    host.close()
+    ioServer.close()
+    await new Promise<void>(resolve => httpServer.close(() => resolve()))
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/replay/replay-listen.test.ts

@@ -0,0 +1,156 @@
+import {replayListen, withReplayListen, ReplayEvent} from '../src/Common/events/replay-index'
+import {createListen, getListenByOn, isListenOn} from '../src/Common/events/Listen'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+
+async function main() {
+    console.log('\n[replay] live mode unchanged')
+    {
+        const [emit, listen] = replayListen<[number]>({history: 10})
+        const seen: number[] = []
+        const off = listen.on(v => seen.push(v))
+        emit(1)
+        emit(2)
+        off()
+        emit(3)
+        ok(seen.join(',') == '1,2', 'plain on(cb) is live-only, off works')
+        ok(listen.head() == 3, 'head counts every journaled emit')
+        ok(isListenOn(listen.on) && getListenByOn(listen.on) === listen, 'decorated on is identity-registered')
+    }
+
+    console.log('\n[replay] current mode unchanged (layer 3)')
+    {
+        let state = 0
+        const [emit0, listen] = replayListen<[number]>({history: 10, current: () => state ? [state] : undefined})
+        const emit = (v: number) => { state = v; emit0(v) }
+        emit(7)
+        const seen: number[] = []
+        listen.on(v => seen.push(v), {current: true})
+        emit(8)
+        ok(seen.join(',') == '7,8', 'on(cb, {current}) = keyframe + live')
+        const once: number[] = []
+        const offOnce = listen.once(v => once.push(v), {current: true})
+        offOnce()
+        ok(once.join(',') == '8' && listen.count() == 1, 'once(current) replays without subscribing')
+    }
+
+    console.log('\n[replay] since catch-up + seamless handover')
+    {
+        const [emit, listen] = replayListen<[string]>({history: 10})
+        emit('a'); emit('b'); emit('c'); emit('d')
+        const seen: string[] = []
+        const seqs: number[] = []
+        listen.on(v => seen.push(v), {since: 2, onSeq: s => seqs.push(s)})
+        emit('e')
+        ok(seen.join(',') == 'c,d,e', 'replay from seq+1 then live, no gap no dup')
+        ok(seqs.join(',') == '3,4,5', 'onSeq reports the seq of every delivered event')
+    }
+    {
+        const [emit, listen] = replayListen<[number]>({history: 10})
+        emit(1)
+        const seen: number[] = []
+        listen.on(v => seen.push(v), {since: 0})
+        emit(2)
+        ok(seen.join(',') == '1,2', 'since: 0 replays the whole journal')
+    }
+    {
+        const [emit, listen] = replayListen<[number]>({history: 10})
+        emit(1); emit(2); emit(3)
+        const seen: number[] = []
+        listen.on(v => seen.push(v), {since: 3})
+        emit(4)
+        ok(seen.join(',') == '4', 'since == head: empty replay, live only')
+    }
+
+    console.log('\n[replay] re-entrant emit during replay (the subtle handover)')
+    {
+        const [emit, listen] = replayListen<[number]>({history: 10})
+        emit(1); emit(2)
+        const seen: number[] = []
+        listen.on(function reentrant(v) {
+            seen.push(v)
+            if (v == 1) emit(100)  // emit from inside replay cb
+        }, {since: 0})
+        emit(3)
+        ok(seen.join(',') == '1,2,100,3', 'live emit during replay queues by seq, delivered once, in order')
+    }
+
+    console.log('\n[replay] eviction fallback: fresh keyframe + line from it')
+    {
+        let state = 0
+        const [emit0, listen] = replayListen<[number]>({history: 3, current: () => [state]})
+        const emit = (v: number) => { state = v; emit0(v) }
+        for (let i = 1; i <= 10; i++) emit(i)
+        const seen: number[] = []
+        const seqs: number[] = []
+        listen.on(v => seen.push(v), {since: 2, onSeq: s => seqs.push(s)})
+        emit(11)
+        ok(seen.join(',') == '10,11', 'evicted seq → keyframe + live, NO backlog queue')
+        ok(seqs.join(',') == '10,11', 'keyframe reports head seq → consumer can resubscribe with since')
+    }
+    {
+        let state = 5
+        const [emit0, listen] = replayListen<[number]>({history: 3, current: () => [state]})
+        const emit = (v: number) => { state = v; emit0(v) }
+        const seen: number[] = []
+        const seqs: number[] = []
+        listen.on(v => seen.push(v), {since: 999, onSeq: s => seqs.push(s)})
+        ok(seen.join(',') == '5' && seqs.join(',') == '0', 'since from the future (server restarted) → keyframe fallback')
+        emit(6)
+        ok(seen.join(',') == '5,6', 'line is reset DOWN: live after the fallback is not muted by the stale big seq')
+    }
+
+    console.log('\n[replay] external journal (memory outside, preferred)')
+    {
+        const journal: ReplayEvent<[number]>[] = []
+        const [emit, listen] = replayListen<[number]>({
+            onJournal: ev => { journal.push(ev); if (journal.length > 3) journal.shift() },
+            getSince: seq => {
+                if (journal.length && seq + 1 < journal[0].seq) return undefined
+                return journal.filter(ev => ev.seq > seq)
+            },
+        })
+        for (let i = 1; i <= 5; i++) emit(i)
+        const seen: number[] = []
+        listen.on(v => seen.push(v), {since: 3})
+        emit(6)
+        ok(seen.join(',') == '4,5,6', 'external getSince drives replay, decorator owns no data')
+        ok(journal.every(ev => typeof ev.ts == 'number'), 'journaled events carry ts attribute')
+        ok(journal.map(ev => ev.seq).join(',') == '4,5,6', 'onJournal saw every seq, external ring evicts')
+    }
+
+    console.log('\n[replay] journal introspection (for layer B)')
+    {
+        const [emit, listen] = replayListen<[number]>({history: 5, now: () => 42})
+        emit(10); emit(20); emit(30)
+        const tail = listen.getSince(1)!
+        ok(tail.map(ev => `${ev.seq}:${ev.event[0]}@${ev.ts}`).join(',') == '2:20@42,3:30@42', 'getSince returns {seq, ts, event} tail')
+        ok(listen.getSince(3)!.length == 0, 'getSince(head) is empty tail')
+        for (let i = 4; i <= 9; i++) emit(i)
+        ok(listen.getSince(1) == undefined, 'evicted seq → undefined (caller falls back to keyframe)')
+    }
+
+    console.log('\n[replay] decorator over an externally-run base (withReplayListen direct)')
+    {
+        const base = createListen<[number]>(() => {})
+        base.run()
+        const listen = withReplayListen(base, {history: 10})
+        listen.emit(1)
+        listen.emit(2)
+        const seen: number[] = []
+        listen.on(v => seen.push(v), {since: 1})
+        listen.emit(3)
+        ok(seen.join(',') == '2,3', 'withReplayListen works over a plain ListenApi')
+        base.emit(99)  // emitted PAST the decorator - not journaled
+        ok(listen.head() == 3 && seen.join(',') == '2,3,99', 'non-journaled emit is delivered live but never journaled')
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main()