wenay-common2 1.0.69 → 1.0.73

package/oracle/regression/observe-core.spec.ts

@@ -0,0 +1,278 @@
+import * as srcApi from '../../src/Common/Observe/reactive'
+import * as observeApi from '../../observe/reactive'
+
+type Fn = () => void
+type Api = typeof srcApi
+
+let failures = 0
+const tests: Array<{name: string; run: () => void | Promise<void>}> = []
+
+function test(name: string, run: () => void | Promise<void>) {
+    tests.push({name, run})
+}
+
+function assert(cond: unknown, message: string) {
+    if (!cond) throw new Error(message)
+}
+
+function assertEq<T>(actual: T, expected: T, message: string) {
+    if (!Object.is(actual, expected)) {
+        throw new Error(`${message}: expected ${String(expected)}, got ${String(actual)}`)
+    }
+}
+
+function assertDeepEq(actual: unknown, expected: unknown, message: string) {
+    const a = JSON.stringify(actual)
+    const e = JSON.stringify(expected)
+    if (a !== e) throw new Error(`${message}: expected ${e}, got ${a}`)
+}
+
+function assertThrows(run: () => void, match: RegExp, message: string) {
+    try {
+        run()
+    } catch (e: any) {
+        assert(match.test(String(e?.message ?? e)), `${message}: wrong error ${String(e?.message ?? e)}`)
+        return
+    }
+    throw new Error(`${message}: did not throw`)
+}
+
+function createManualDrain() {
+    const queue: Fn[] = []
+    return {
+        opts: {drain: (f: Fn) => { queue.push(f) }},
+        get pending() { return queue.length },
+        flushOne() {
+            const f = queue.shift()
+            if (f) f()
+        },
+        flushAll(limit = 20) {
+            let count = 0
+            while (queue.length) {
+                if (++count > limit) throw new Error('manual drain did not settle')
+                queue.shift()!()
+            }
+        },
+        clear() { queue.length = 0 },
+    }
+}
+
+async function tick() {
+    await new Promise<void>(resolve => setTimeout(resolve, 0))
+}
+
+function addCoreSuite(label: string, api: Api) {
+    const {reactive, onUpdate, flushReactive, listenUpdate} = api
+
+    test(`${label}: nested subscriptions fire only for affected branches`, () => {
+        const drain = createManualDrain()
+        const s = reactive<any>({a: {b: {c: 1}, d: 1}, z: 1}, drain.opts)
+        let root = 0, a = 0, b = 0
+        onUpdate(s, () => root++)
+        onUpdate(s.a, () => a++)
+        onUpdate(s.a.b, () => b++)
+
+        s.a.b.c = 2
+        drain.flushAll()
+        assertDeepEq({root, a, b}, {root: 1, a: 1, b: 1}, 'deep child update reaches root, parent, and child')
+
+        s.a.d = 2
+        drain.flushAll()
+        assertDeepEq({root, a, b}, {root: 2, a: 2, b: 1}, 'sibling update does not notify nested child subscriber')
+    })
+
+    test(`${label}: whole-branch replacement preserves captured subscriptions`, () => {
+        const drain = createManualDrain()
+        const s = reactive<any>({branch: {leaf: {value: 1}, other: 1}}, drain.opts)
+        const branch = s.branch
+        const leaf = s.branch.leaf
+        let branchHits = 0, leafHits = 0
+        onUpdate(branch, () => branchHits++)
+        onUpdate(leaf, () => leafHits++)
+
+        s.branch = {leaf: {value: 2}, other: 9}
+        drain.flushAll()
+        assertEq(branch.valueOf(), branch, 'captured branch proxy remains usable')
+        assertEq(branch.leaf.value, 2, 'captured branch reads replacement target')
+        assertEq(leaf.value, 2, 'captured leaf reads replacement target')
+        assertDeepEq({branchHits, leafHits}, {branchHits: 1, leafHits: 1}, 'replacement notifies existing branch and leaf watchers')
+
+        leaf.value = 3
+        drain.flushAll()
+        assertEq(s.branch.leaf.value, 3, 'captured leaf writes through to replacement branch')
+        assertDeepEq({branchHits, leafHits}, {branchHits: 2, leafHits: 2}, 'post-replacement deep write still bubbles')
+    })
+
+    test(`${label}: delete detaches captured child proxies`, () => {
+        const drain = createManualDrain()
+        const manual = reactive<any>({child: {x: 1}}, drain.opts)
+        const oldChild = manual.child
+        let rootHits = 0, childHits = 0
+        onUpdate(manual, () => rootHits++)
+        onUpdate(oldChild, () => childHits++)
+
+        delete manual.child
+        drain.flushAll()
+        assertDeepEq({rootHits, childHits, hasChild: 'child' in manual}, {rootHits: 1, childHits: 1, hasChild: false}, 'delete notifies live root and deleted child once')
+
+        oldChild.x = 2
+        drain.flushAll()
+        assertDeepEq({rootHits, childHits}, {rootHits: 1, childHits: 1}, 'mutating detached child no longer bubbles')
+        assertThrows(() => onUpdate(oldChild, () => {}), /detached/, 'new subscription to detached proxy is rejected after delete')
+    })
+
+    test(`${label}: defineProperty handles configurable and non-configurable descriptors`, () => {
+        const drain = createManualDrain()
+        const s = reactive<any>({}, drain.opts)
+        let hits = 0
+        onUpdate(s, () => hits++)
+
+        Object.defineProperty(s, 'open', {value: {x: 1}, enumerable: true, configurable: true, writable: true})
+        const open = s.open
+        drain.flushAll()
+        assertEq(hits, 1, 'configurable defineProperty notifies once')
+        assertEq(open.x, 1, 'configurable object property is reactive on read')
+
+        Object.defineProperty(s, 'open', {value: {x: 2}, enumerable: true, configurable: true, writable: true})
+        drain.flushAll()
+        assertEq(open.x, 2, 'configurable descriptor replacement rebinds captured child')
+
+        Object.defineProperty(s, 'fixed', {value: 7, enumerable: true, configurable: false, writable: false})
+        drain.flushAll()
+        assertEq(hits, 3, 'non-configurable defineProperty notifies once')
+        assertDeepEq(Object.keys(s).sort(), ['fixed', 'open'], 'non-configurable key remains enumerable through proxy invariants')
+        assertThrows(() => { s.fixed = 8 }, /read only|trap returned falsish|Cannot assign/i, 'non-writable non-configurable property rejects writes')
+        drain.flushAll()
+        assertEq(s.fixed, 7, 'failed non-configurable write leaves value unchanged')
+        assertEq(hits, 3, 'failed non-configurable write does not notify')
+    })
+
+    test(`${label}: arrays are reactive containers and survive replacement`, () => {
+        const drain = createManualDrain()
+        const s = reactive<any>({items: [{v: 1}]}, drain.opts)
+        const arr = s.items
+        const first = s.items[0]
+        let rootHits = 0, arrHits = 0, firstHits = 0
+        onUpdate(s, () => rootHits++)
+        onUpdate(arr, () => arrHits++)
+        onUpdate(first, () => firstHits++)
+
+        s.items[0].v = 2
+        s.items.push({v: 3})
+        drain.flushAll()
+        assertDeepEq({rootHits, arrHits, firstHits}, {rootHits: 1, arrHits: 1, firstHits: 1}, 'index write and push coalesce')
+        assert(Array.isArray(s.items), 'wrapped array passes Array.isArray')
+        assertEq(JSON.stringify(s.items), '[{"v":2},{"v":3}]', 'wrapped array serializes as an array')
+
+        s.items = [{v: 4}]
+        drain.flushAll()
+        assertEq(arr[0].v, 4, 'captured array proxy follows replacement')
+        assertEq(first.v, 4, 'captured array element proxy follows replacement element')
+    })
+
+    test(`${label}: listenUpdate is cold until first listener and cold again after last off`, () => {
+        const drain = createManualDrain()
+        const s = reactive<any>({node: {x: 1}}, drain.opts)
+        const updates = listenUpdate(s.node)
+        let hits = 0
+
+        s.node.x = 2
+        assertEq(drain.pending, 0, 'listenUpdate without downstream listeners does not schedule')
+
+        const off = updates.on(() => hits++)
+        s.node.x = 3
+        assertEq(drain.pending, 1, 'first listener makes listenUpdate hot')
+        drain.flushAll()
+        assertEq(hits, 1, 'hot listenUpdate emits update')
+
+        off()
+        drain.clear()
+        s.node.x = 4
+        assertEq(drain.pending, 0, 'last off makes listenUpdate cold again')
+        drain.flushAll()
+        assertEq(hits, 1, 'cold listenUpdate no longer emits')
+    })
+
+    test(`${label}: duplicate onUpdate callbacks are independent subscriptions`, () => {
+        const drain = createManualDrain()
+        const s = reactive({x: 0}, drain.opts)
+        let hits = 0
+        const cb = () => hits++
+        const off1 = onUpdate(s, cb)
+        const off2 = onUpdate(s, cb)
+
+        off1()
+        s.x = 1
+        drain.flushAll()
+        assertEq(hits, 1, 'second duplicate subscription remains after first off')
+
+        off2()
+        s.x = 2
+        drain.flushAll()
+        assertEq(hits, 1, 'second off removes remaining duplicate subscription')
+    })
+
+    test(`${label}: flushReactive waits for batching and follow-up drains`, async () => {
+        const drain = createManualDrain()
+        const s = reactive({x: 0}, drain.opts)
+        let hits = 0
+        let resolved = false
+        onUpdate(s, () => {
+            hits++
+            if (hits === 1) s.x = 2
+        })
+
+        s.x = 1
+        const done = flushReactive(s).then(() => { resolved = true })
+        assertEq(hits, 0, 'callbacks do not run synchronously')
+        drain.flushOne()
+        assertEq(resolved, false, 'flushReactive waits for callback-triggered follow-up drain')
+        drain.flushAll()
+        await done
+        assertDeepEq({hits, value: s.x, resolved}, {hits: 2, value: 2, resolved: true}, 'flushReactive resolves after settled state')
+    })
+
+    test(`${label}: subscriber errors are isolated and rethrown asynchronously`, async () => {
+        const drain = createManualDrain()
+        const s = reactive({x: 0}, drain.opts)
+        let siblingHits = 0
+        let uncaught: any = null
+        const onUncaught = (e: any) => { uncaught = e }
+        process.once('uncaughtException', onUncaught)
+
+        onUpdate(s, () => { throw new Error(`${label} boom`) })
+        onUpdate(s, () => siblingHits++)
+        s.x = 1
+        const done = flushReactive(s)
+        drain.flushAll()
+        await done
+        await tick()
+        process.removeListener('uncaughtException', onUncaught)
+
+        assertEq(siblingHits, 1, 'sibling subscriber still runs after another subscriber throws')
+        assertEq(uncaught?.message, `${label} boom`, 'subscriber error is rethrown asynchronously')
+    })
+}
+
+addCoreSuite('src/Common/Observe/reactive', srcApi)
+addCoreSuite('observe/reactive', observeApi)
+
+async function main() {
+    for (const t of tests) {
+        try {
+            await t.run()
+            console.log(`OK ${t.name}`)
+        } catch (e: any) {
+            failures++
+            console.error(`FAIL ${t.name}`)
+            console.error(e?.stack ?? e)
+        }
+    }
+    console.log(failures === 0 ? `ALL GREEN (${tests.length})` : `${failures} FAILURE(S) / ${tests.length}`)
+    process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch(e => {
+    console.error(e?.stack ?? e)
+    process.exit(1)
+})

package/oracle/regression/package-export.spec.ts

@@ -0,0 +1,120 @@
+import {existsSync} from 'node:fs'
+import {createRequire} from 'node:module'
+import {resolve} from 'node:path'
+
+import * as srcIndex from '../../src/index'
+import * as srcObserve from '../../src/Common/Observe/reactive'
+
+type Api = {
+    reactive: Function
+    onUpdate: Function
+    flushReactive: Function
+    listenUpdate: Function
+}
+
+let failures = 0
+const tests: Array<{name: string; run: () => void | Promise<void>}> = []
+const requireFromSpec = createRequire(__filename)
+const rootDir = resolve(__dirname, '../..')
+
+function test(name: string, run: () => void | Promise<void>) {
+    tests.push({name, run})
+}
+
+function assert(cond: unknown, message: string) {
+    if (!cond) throw new Error(message)
+}
+
+function assertEq<T>(actual: T, expected: T, message: string) {
+    if (!Object.is(actual, expected)) {
+        throw new Error(`${message}: expected ${String(expected)}, got ${String(actual)}`)
+    }
+}
+
+function assertApi(label: string, api: any): asserts api is Api {
+    assert(api, `${label} is missing`)
+    assertEq(typeof api.reactive, 'function', `${label}.reactive export`)
+    assertEq(typeof api.onUpdate, 'function', `${label}.onUpdate export`)
+    assertEq(typeof api.flushReactive, 'function', `${label}.flushReactive export`)
+    assertEq(typeof api.listenUpdate, 'function', `${label}.listenUpdate export`)
+}
+
+function skip(name: string, reason: string) {
+    console.log(`SKIP ${name}: ${reason}`)
+}
+
+test('src/Common/Observe/reactive direct import exposes Observe API', () => {
+    assertApi('src/Common/Observe/reactive', srcObserve)
+})
+
+test('src/index exports Observe namespace', () => {
+    assertApi('src/index Observe', srcIndex.Observe)
+    assertEq(srcIndex.Observe.reactive, srcObserve.reactive, 'src/index Observe.reactive re-exports direct src module')
+    assertEq(srcIndex.Observe.onUpdate, srcObserve.onUpdate, 'src/index Observe.onUpdate re-exports direct src module')
+})
+
+test("package.json exports './observe'", () => {
+    const packageJson = requireFromSpec(resolve(rootDir, 'package.json'))
+    assertEq(packageJson.exports?.['./observe'], './lib/Common/Observe/index.js', "package.json exports['./observe']")
+
+    const resolved = requireFromSpec.resolve('wenay-common2/observe')
+    assert(
+        resolved.replace(/\\/g, '/').endsWith('/lib/Common/Observe/index.js'),
+        `wenay-common2/observe resolved to unexpected path: ${resolved}`,
+    )
+    assertApi('wenay-common2/observe', requireFromSpec('wenay-common2/observe'))
+})
+
+test('lib root index exports Observe namespace', () => {
+    const libIndex = resolve(rootDir, 'lib/index.js')
+    if (!existsSync(libIndex)) {
+        skip('lib root index exports Observe namespace', 'lib/index.js is not present')
+        return
+    }
+
+    const libApi = requireFromSpec(libIndex)
+    assertApi('lib/index Observe', libApi.Observe)
+})
+
+test('dist package artifacts include observe export when dist is present', () => {
+    const distDir = resolve(rootDir, 'dist')
+    if (!existsSync(distDir)) {
+        skip('dist package artifacts include observe export when dist is present', 'dist directory is not present')
+        return
+    }
+
+    const distPackageJsonPath = resolve(distDir, 'package.json')
+    const distObserveJs = resolve(distDir, 'lib/Common/Observe/reactive.js')
+    const distObserveDts = resolve(distDir, 'lib/Common/Observe/reactive.d.ts')
+    const distIndexJs = resolve(distDir, 'lib/index.js')
+
+    assert(existsSync(distPackageJsonPath), 'dist/package.json is present')
+    assert(existsSync(distObserveJs), 'dist observe JavaScript artifact is present')
+    assert(existsSync(distObserveDts), 'dist observe declaration artifact is present')
+    assert(existsSync(distIndexJs), 'dist lib/index.js artifact is present')
+
+    const distPackageJson = requireFromSpec(distPackageJsonPath)
+    assertEq(distPackageJson.exports?.['./observe'], './lib/Common/Observe/index.js', "dist package exports['./observe']")
+    assertApi('dist/lib/Common/Observe/reactive.js', requireFromSpec(distObserveJs))
+    assertApi('dist/lib/index.js Observe', requireFromSpec(distIndexJs).Observe)
+})
+
+async function main() {
+    for (const t of tests) {
+        try {
+            await t.run()
+            console.log(`OK ${t.name}`)
+        } catch (e: any) {
+            failures++
+            console.error(`FAIL ${t.name}`)
+            console.error(e?.stack ?? e)
+        }
+    }
+    console.log(failures === 0 ? `ALL GREEN (${tests.length})` : `${failures} FAILURE(S) / ${tests.length}`)
+    process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch(e => {
+    console.error(e?.stack ?? e)
+    process.exit(1)
+})

package/oracle/regression/rpc-dedupe-callbacks.spec.ts

@@ -0,0 +1,195 @@
+import { createRpcClient } from "../../src/Common/rcp/rpc-client"
+import { createRpcServerAuto } from "../../src/Common/rcp/rpc-server-auto"
+import { type SocketTmpl } from "../../src/Common/rcp/rpc-protocol"
+import { listen as createListenPair } from "../../src/Common/events/Listen"
+
+function createLoopback(): [SocketTmpl, SocketTmpl] {
+    const a: Record<string, ((d: any) => void)[]> = {}
+    const b: Record<string, ((d: any) => void)[]> = {}
+    const make = (mine: typeof a, theirs: typeof a): SocketTmpl => ({
+        on: (e, cb) => { (mine[e] ??= []).push(cb) },
+        emit: (e, d) => {
+            const wire = d === undefined ? undefined : JSON.parse(JSON.stringify(d))
+            for (const cb of (theirs[e] ?? [])) queueMicrotask(() => cb(wire))
+        },
+    })
+    return [make(a, b), make(b, a)]
+}
+
+const delay = (ms = 0) => new Promise<void>(r => setTimeout(r, ms))
+
+function eq(a: any, b: any): boolean {
+    if (a === b) return true
+    if (typeof a === "bigint" || typeof b === "bigint") return a === b
+    if (a instanceof Date && b instanceof Date) return a.valueOf() === b.valueOf()
+    if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size) return false
+        for (const [k, v] of a) if (!eq(v, b.get(k))) return false
+        return true
+    }
+    if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size) return false
+        for (const v of a) if (![...b].some(x => eq(x, v))) return false
+        return true
+    }
+    if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => eq(v, b[i]))
+    if (a && b && typeof a === "object" && typeof b === "object") {
+        const ak = Object.keys(a), bk = Object.keys(b)
+        return ak.length === bk.length && ak.every(k => eq(a[k], b[k]))
+    }
+    return false
+}
+
+function fmt(v: any): string {
+    return typeof v === "bigint" ? `${v}n` : JSON.stringify(v)
+}
+
+function makeChecker() {
+    let fails = 0
+    async function check<T>(name: string, run: () => T | Promise<T>, exp: T) {
+        try {
+            const got = await run()
+            const ok = eq(got, exp)
+            if (!ok) fails++
+            console.log(`${ok ? "PASS" : "FAIL"}  ${name}  got=${fmt(got)} exp=${fmt(exp)}`)
+        } catch (e: any) {
+            fails++
+            console.log(`FAIL  ${name}  threw=${e?.message ?? e}`)
+        }
+    }
+    return { check, done: () => fails }
+}
+
+function nextUncaught(ms = 200) {
+    return new Promise<string | null>(resolve => {
+        const timer = setTimeout(() => {
+            process.removeListener("uncaughtException", onError)
+            resolve(null)
+        }, ms)
+        const onError = (e: any) => {
+            clearTimeout(timer)
+            resolve(e?.message ?? String(e))
+        }
+        process.once("uncaughtException", onError)
+    })
+}
+
+function makeRpcListen() {
+    const [emit, stream] = createListenPair<number>()
+    const obj = { stream }
+    const [clientSocket, serverSocket] = createLoopback()
+    const client = createRpcClient<typeof obj>({ socket: clientSocket, socketKey: "rpc" })
+    const server = createRpcServerAuto({ socket: serverSocket, object: obj, socketKey: "rpc" })
+    return { emit, client, server, api: client.func as any }
+}
+
+async function main() {
+    const { check, done } = makeChecker()
+    const watchdog = setTimeout(() => {
+        console.error("WATCHDOG timeout")
+        process.exit(3)
+    }, 10000)
+
+    {
+        const { emit, client, server, api } = makeRpcListen()
+        await delay(0)
+        const got: string[] = []
+        api.stream.callback((v: number) => { got.push(`first:${v}`); throw new Error("first consumer boom") })
+        api.stream.callback((v: number) => got.push(`second:${v}`))
+        await delay(10)
+
+        const thrown = nextUncaught()
+        emit(3)
+        await delay(20)
+
+        await check("fan-out isolation: both consumers ran", () => got, ["first:3", "second:3"])
+        await check("fan-out isolation: first throw surfaced async", () => thrown, "first consumer boom")
+        await check("fan-out isolation: one wire subscription", () => client.api.subscriptions()[0]?.consumers, 2)
+        await check("fan-out isolation: server has one consumer", () => server.api.subscriptions()[0]?.consumers, 1)
+    }
+
+    {
+        const { emit, client, server, api } = makeRpcListen()
+        await delay(0)
+        const a: number[] = [], b: number[] = []
+        const richA = { id: 1n, tags: new Set(["a", "b"]), meta: new Map<any, any>([["x", 1]]) }
+        const richB = { id: 2n, tags: new Set(["a", "c"]), meta: new Map<any, any>([["x", 2]]) }
+
+        let subscribeError: any = null
+        try {
+            api.stream.callback((v: number) => a.push(v), richA)
+            api.stream.callback((v: number) => b.push(v), richB)
+        } catch (e) {
+            subscribeError = e
+        }
+        await delay(20)
+        emit(8)
+        await delay(20)
+
+        await check("rich dedupe key: subscribe did not throw", () => subscribeError?.message ?? null, null)
+        await check("rich dedupe key: distinct rich args do not collide client-side", () => client.api.subscriptions().length, 2)
+        await check("rich dedupe key: distinct rich args do not collide server-side", () => server.api.subscriptions()[0]?.consumers, 2)
+        await check("rich dedupe key: first rich subscription receives", () => a, [8])
+        await check("rich dedupe key: second rich subscription receives", () => b, [8])
+    }
+
+    {
+        const { emit, client, server, api } = makeRpcListen()
+        await delay(0)
+        const got: number[] = []
+        const cb = (v: number) => got.push(v)
+        const off1 = api.stream.callback(cb)
+        const off2 = api.stream.callback(cb)
+        await delay(20)
+
+        emit(1)
+        await delay(20)
+        off1()
+        await delay(20)
+        const afterFirstOff = {
+            clientConsumers: client.api.subscriptions()[0]?.consumers,
+            serverConsumers: server.api.subscriptions()[0]?.consumers,
+        }
+        emit(2)
+        await delay(20)
+        off2()
+        await delay(30)
+
+        await check("duplicate same callback: local duplicate fan-out before off", () => got, [1, 1, 2])
+        await check("duplicate same callback: one local consumer remains after first off", () => afterFirstOff.clientConsumers, 1)
+        await check("duplicate same callback: server still has one wire consumer after first off", () => afterFirstOff.serverConsumers, 1)
+        await check("duplicate same callback: client cleaned after last off", () => client.api.subscriptions().length, 0)
+        await check("duplicate same callback: server cleaned after last off", () => server.api.subscriptions().length, 0)
+    }
+
+    {
+        const { emit, client, server, api } = makeRpcListen()
+        await delay(0)
+        const a: number[] = [], b: number[] = []
+        const offA = api.stream.callback((v: number) => a.push(v))
+        api.stream.callback((v: number) => b.push(v))
+        await delay(20)
+
+        emit(5)
+        await delay(20)
+        offA()
+        await delay(20)
+        emit(6)
+        await delay(20)
+
+        await check("unsub one consumer: removed consumer stopped", () => a, [5])
+        await check("unsub one consumer: other consumer kept receiving", () => b, [5, 6])
+        await check("unsub one consumer: client still has shared wire sub", () => client.api.subscriptions()[0]?.consumers, 1)
+        await check("unsub one consumer: server wire consumer still alive", () => server.api.subscriptions()[0]?.consumers, 1)
+    }
+
+    clearTimeout(watchdog)
+    const fails = done()
+    console.log(fails === 0 ? "ALL GREEN" : `${fails} FAILURE(S)`)
+    process.exit(fails === 0 ? 0 : 1)
+}
+
+main().catch(e => {
+    console.error(e)
+    process.exit(2)
+})