wenay-common2 1.0.74 → 1.0.76

package/lib/Common/rcp/rpc-clientHub.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rpc = rpc;
 exports.createRpcClientHub = createRpcClientHub;
 const rpc_client_1 = require("./rpc-client");
+const transport_lifecycle_1 = require("../events/transport-lifecycle");
 function rpc(socketKey) {
     return { socketKey };
 }
@@ -14,43 +15,127 @@ function createRpcClientHub(createSocket, schemaBuilder, hubOpts) {
     let connectCount = 0;
     let onConnectCb = null;
     let onDisconnectCb = null;
+    const connectCbs = new Set();
+    const disconnectCbs = new Set();
+    let activeContext = null;
     let resolveFunc = null;
     let promise = new Promise((resolve) => {
         resolveFunc = resolve;
     });
+    function callObserver(cb, value, errors) {
+        try {
+            cb(value);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    function rethrowObserverErrors(errors) {
+        for (const error of errors) {
+            setTimeout(function rethrowLifecycleObserverError() { throw error; }, 0);
+        }
+    }
+    function notifyConnect(count) {
+        const errors = [];
+        const legacy = onConnectCb;
+        if (legacy)
+            callObserver(legacy, count, errors);
+        for (const cb of [...connectCbs])
+            callObserver(cb, count, errors);
+        rethrowObserverErrors(errors);
+    }
+    function notifyDisconnect(context, reason) {
+        if (context.disconnectNotified)
+            return;
+        context.disconnectNotified = true;
+        const errors = [];
+        const legacy = onDisconnectCb;
+        if (legacy)
+            callObserver(legacy, reason, errors);
+        for (const cb of [...disconnectCbs])
+            callObserver(cb, reason, errors);
+        rethrowObserverErrors(errors);
+    }
+    function closeContext(context, reason) {
+        if (context.terminal)
+            return;
+        context.terminal = true;
+        context.connected = false;
+        context.attempt++;
+        for (const client of context.clients)
+            client[transport_lifecycle_1.RPC_TRANSPORT_CONTROL]?.close(reason);
+        for (const client of context.clients)
+            client.dispose?.(reason, { socketAlive: false });
+        context.socket.disconnect?.();
+        notifyDisconnect(context, reason);
+    }
+    async function handshakeAndConnect(context, attempt, count) {
+        await Promise.all(context.clients.map(function initClient(client) {
+            return client.initStrict?.();
+        }));
+        if (activeContext != context || context.terminal || !context.connected || context.attempt != attempt)
+            return;
+        for (const client of context.clients)
+            client[transport_lifecycle_1.RPC_TRANSPORT_CONTROL]?.connect();
+        if (activeContext != context || context.terminal || !context.connected || context.attempt != attempt)
+            return;
+        notifyConnect(count);
+        if (activeContext != context || context.terminal || !context.connected || context.attempt != attempt)
+            return;
+        if (resolveFunc) {
+            const resolve = resolveFunc;
+            resolveFunc = null;
+            resolve(facade);
+        }
+    }
     function setToken(token) {
-        const hadSocket = socket != null;
-        socket?.disconnect?.();
-        for (const key in schema)
-            facade[key]?.dispose?.("token rotated", { socketAlive: false });
-        if (hadSocket)
-            onDisconnectCb?.("token rotated");
+        if (activeContext)
+            closeContext(activeContext, 'token rotated');
         if (!resolveFunc)
             promise = new Promise((resolve) => { resolveFunc = resolve; });
         currentToken = token;
-        socket = createSocket(token);
+        const nextSocket = createSocket(token);
+        socket = nextSocket;
+        const clients = [];
         for (const key in schema) {
             const targetSocketKey = schema[key].socketKey || key;
-            const client = (0, rpc_client_1.createRpcClient)({ socketKey: targetSocketKey, socket, token, opt: hubOpts?.opt });
+            const client = (0, rpc_client_1.createRpcClient)({ socketKey: targetSocketKey, socket: nextSocket, token, opt: hubOpts?.opt });
+            const transportClient = client;
+            transportClient[transport_lifecycle_1.RPC_TRANSPORT_CONTROL]?.disconnect('RPC hub awaiting handshake');
             facade[key] = client;
+            clients.push(transportClient);
         }
-        function hi() {
-            for (const key in schema) {
-                const client = facade[key];
-                if (client && typeof client.initStrict === "function") {
-                    client.initStrict();
-                }
-            }
-        }
-        socket?.on("connect", () => {
-            connectCount++;
-            hi();
-            onConnectCb?.(connectCount);
-            if (resolveFunc) {
-                const a = resolveFunc;
-                resolveFunc = null;
-                a(facade);
-            }
+        const context = {
+            socket: nextSocket,
+            clients,
+            connected: false,
+            terminal: false,
+            attempt: 0,
+            disconnectNotified: false,
+        };
+        activeContext = context;
+        nextSocket.on('connect', function onSocketConnect() {
+            if (activeContext != context || context.terminal)
+                return;
+            context.connected = true;
+            context.disconnectNotified = false;
+            const attempt = ++context.attempt;
+            const count = ++connectCount;
+            handshakeAndConnect(context, attempt, count).catch(function reportHandshakeError(error) {
+                if (activeContext != context || context.terminal || context.attempt != attempt)
+                    return;
+                setTimeout(function rethrowHandshakeError() { throw error; }, 0);
+            });
+        });
+        nextSocket.on('disconnect', function onSocketDisconnect(reason) {
+            if (activeContext != context || context.terminal || !context.connected)
+                return;
+            context.connected = false;
+            context.attempt++;
+            const disconnectReason = typeof reason == 'string' ? reason : String(reason ?? 'socket disconnected');
+            for (const client of context.clients)
+                client[transport_lifecycle_1.RPC_TRANSPORT_CONTROL]?.disconnect(disconnectReason);
+            notifyDisconnect(context, disconnectReason);
         });
         return promise;
     }
@@ -64,6 +149,14 @@ function createRpcClientHub(createSocket, schemaBuilder, hubOpts) {
         }
         return Promise.all(ps);
     }
+    function connectListen(cb) {
+        connectCbs.add(cb);
+        return function offConnect() { connectCbs.delete(cb); };
+    }
+    function disconnectListen(cb) {
+        disconnectCbs.add(cb);
+        return function offDisconnect() { disconnectCbs.delete(cb); };
+    }
     const result = {
         get promise() { return promise; },
         facade,
@@ -73,6 +166,8 @@ function createRpcClientHub(createSocket, schemaBuilder, hubOpts) {
         get socket() { return socket; },
         onConnect: (func) => { onConnectCb = func ?? null; },
         onDisconnect: (func) => { onDisconnectCb = func ?? null; },
+        connectListen,
+        disconnectListen,
         connectCount: () => connectCount,
     };
     return result;

package/lib/Common/rcp/rpc-server.js

@@ -125,10 +125,12 @@ function createServer(socket, key, target, hooks, limits, auth, opt) {
     const sendCbEnd = (cbId) => { cbShapes.drop(cbId); send([rpc_protocol_1.Pkt.CB_END, cbId]); };
     let authed = !auth?.gate;
     let authAck = undefined;
+    let helloInFlight = null;
     const sendMap = () => send(authAck !== undefined
         ? [rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, authAck]
         : [rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths]);
-    sendMap();
+    if (!auth?.resolveAuth)
+        sendMap();
     if (serverCaps)
         send([rpc_protocol_1.Pkt.CAPS, serverCaps]);
     let detached = false;
@@ -147,6 +149,11 @@ function createServer(socket, key, target, hooks, limits, auth, opt) {
         if (detached)
             return;
         if (msg == rpc_protocol_1.Pkt.STRICT) {
+            const hello = helloInFlight;
+            if (hello) {
+                await hello;
+                return;
+            }
             sendMap();
             return;
         }
@@ -159,21 +166,38 @@ function createServer(socket, key, target, hooks, limits, auth, opt) {
                 send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, null]);
                 return;
             }
+            async function resolveHello() {
+                try {
+                    const r = await auth.resolveAuth(msg[1]);
+                    if (r && r.object !== undefined)
+                        buildDispatch(r.object);
+                    authAck = r && r.ack !== undefined ? r.ack : { ok: true };
+                    authed = authAck?.ok !== false;
+                    sendMap();
+                }
+                catch (e) {
+                    send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, { ok: false, reason: e?.message ?? String(e) }]);
+                }
+            }
+            const hello = resolveHello();
+            helloInFlight = hello;
             try {
-                const r = await auth.resolveAuth(msg[1]);
-                if (r && r.object !== undefined)
-                    buildDispatch(r.object);
-                authAck = r && r.ack !== undefined ? r.ack : { ok: true };
-                authed = authAck?.ok !== false;
-                sendMap();
+                await hello;
             }
-            catch (e) {
-                send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, { ok: false, reason: e?.message ?? String(e) }]);
+            finally {
+                if (helloInFlight == hello)
+                    helloInFlight = null;
             }
             return;
         }
         if (!Array.isArray(msg) || (msg[0] !== rpc_protocol_1.Pkt.CALL && msg[0] !== rpc_protocol_1.Pkt.PIPE))
             return;
+        const hello = helloInFlight;
+        if (hello) {
+            await hello;
+            if (detached)
+                return;
+        }
         const isPipe = msg[0] === rpc_protocol_1.Pkt.PIPE;
         const [, reqId, ref, rawArgsOrSteps, w] = msg;
         const wait = w !== false;

package/observe/store-manager.test.ts

@@ -7,6 +7,7 @@ import {
     flushReactive,
     managedStore,
 } from '../src/Common/Observe'
+import {isNoStrict, noStrict} from '../src/Common/rcp/rpc-dynamic'
 
 let fails = 0
 const ok = (condition: any, message: string) => {
@@ -111,8 +112,49 @@ async function main() {
         ok(manager.handles.rows.status().state == 'stopped', 'stopAll closes offline resource')
     }
 
+    console.log('\n[store-manager] dynamic account-map lifecycle')
+    {
+        const sources = new Map<string, ReturnType<typeof createStore<Market>>>()
+        const remotes = noStrict(new Proxy({} as Record<string, any>, {
+            get(_target, key) {
+                if (typeof key != 'string') return undefined
+                let source = sources.get(key)
+                if (!source) {
+                    source = createStore<Market>({data: {BTC: key.length}, meta: {status: 'relay'}}, {drain: 'micro'})
+                    sources.set(key, source)
+                }
+                return exposeStoreReplay(source, {history: 20}).api.replay
+            },
+        }))
+        function accountResource(account: string) {
+            return managedStore.replay<Market>({
+                remote: remotes[account],
+                initial: {data: {}, meta: {}},
+                storeOpts: {drain: 'micro'},
+            })
+        }
+        const manager = createStoreManager({
+            alice: accountResource('alice'),
+            bob: accountResource('bob'),
+        })
+
+        ok(isNoStrict(remotes), 'runtime account map is explicitly noStrict, not a fixed schema')
+        const alice = await manager.start('alice')
+        ok(alice.state.data.BTC == 5 && manager.get('bob') == null, 'start selects one account mirror without materializing its peers')
+
+        const source = sources.get('alice')!
+        source.state.meta.status = 'direct'
+        await settle(source.state)
+        ok(alice.state.meta.status == 'direct', 'selected account mirror follows its replay route')
+
+        manager.stop('alice')
+        ok(manager.handles.alice.status().state == 'stopped' && manager.get('alice') != null,
+            'stopping a selected account detaches its route while retaining its local mirror for reuse')
+        manager.stopAll()
+    }
+
     console.log(`\n${fails == 0 ? 'ALL GREEN' : fails + ' FAILURE(S)'}`)
     process.exit(fails == 0 ? 0 : 1)
 }
 
-main().catch(e => { console.error(e); process.exit(1) })
+main().catch(e => { console.error(e); process.exit(1) })

package/oracle/realsocket/lifecycle.spec.ts

@@ -1,6 +1,6 @@
-// REAL-SOCKET lifecycle: disconnect teardown drains live subscriptions, fires
-// onDisconnect (client + hub), and hard setToken rotation tears down old subs then
-// reconnects (connectCount++). Default = teardown, NO auto-resubscribe. Port 4108.
+// REAL-SOCKET intentional teardown lifecycle: client.dispose() drains live subscriptions,
+// and hard setToken rotation fires onDisconnect, tears down old subs, then connects a fresh
+// socket generation (connectCount++). Neither hard boundary auto-resubscribes. Port 4108.
 import {startRealServer, startRealClient, makeChecker, delay} from './_rs'
 import {listen as createListenPair} from '../../src/Common/events/Listen'
 

package/oracle/realsocket/replay-reconnect-auth.spec.ts

@@ -0,0 +1,111 @@
+// REAL-SOCKET regression: reconnect recovery must wait for delayed in-band auth
+// before recreating the physical replay subscription. Port 4125.
+import {startRealServer, startRealClient, makeChecker, delay} from './_rs'
+import {replayListen} from '../../src/Common/events/replay-listen'
+import {exposeReplay, replaySubscribe, ReplayRemote} from '../../src/Common/events/replay-wire'
+
+const PORT = 4125
+const WAIT_MS = 10000
+const AUTH_DELAY_MS = 180
+
+const [emit, replay] = replayListen<[number]>({history: 16})
+const principal = {replay: exposeReplay(replay)}
+const serverApis: any[] = []
+let authCount = 0
+
+async function resolveAuth(token: any) {
+    authCount++
+    await delay(AUTH_DELAY_MS)
+    if (token != 'replay-token') throw new Error('bad token')
+    return {object: principal, ack: {ok: true}}
+}
+
+function rememberServer(api: any) {
+    serverApis.push(api)
+}
+
+function serverSubscriberCount() {
+    let total = 0
+    for (const api of serverApis) {
+        for (const sub of api.subscriptions()) total += sub.consumers
+    }
+    return total
+}
+
+async function waitFor(name: string, predicate: () => boolean, timeoutMs = WAIT_MS) {
+    const deadline = Date.now() + timeoutMs
+    while (Date.now() < deadline) {
+        if (predicate()) return
+        await delay(10)
+    }
+    throw new Error('timeout waiting for ' + name)
+}
+
+async function main() {
+    const {check, done} = makeChecker('replay-reconnect-auth')
+    const watchdog = setTimeout(function watchdogExpired() {
+        console.error('WATCHDOG timeout')
+        process.exit(3)
+    }, 40000)
+
+    const srv = await startRealServer({
+        port: PORT,
+        makeObject: function makeGatedObject() { return {} },
+        serverOpts: {auth: {resolveAuth, gate: true}},
+        onServer: rememberServer,
+    })
+    const cli = await startRealClient({port: PORT, token: 'replay-token'})
+    const remote = (cli.client.func as any).replay as ReplayRemote<[number]>
+    const values: number[] = []
+    const seqs: number[] = []
+    const sub = replaySubscribe(remote, function receiveValue(value) {
+        values.push(value)
+    }, {
+        since: 0,
+        onSeq: function rememberSeq(seq) { seqs.push(seq) },
+    })
+    await sub.ready
+
+    emit(1)
+    await waitFor('initial live seq 1', () => values.length == 1)
+
+    const socket = cli.hub.socket as any
+    const connectCount = cli.hub.connectCount()
+    const authBeforeReconnect = authCount
+    const engine = socket.io?.engine
+    if (!engine?.close) throw new Error('Engine.IO close() is unavailable')
+    engine.close()
+    await waitFor('transport disconnect', () => !socket.connected)
+
+    emit(2)
+    await waitFor('same Socket.IO object reconnect', () =>
+        socket.connected && cli.hub.connectCount() == connectCount + 1)
+    await waitFor('authenticated catch-up seq 2', () =>
+        values.length == 2 && serverSubscriberCount() == 1)
+
+    // The physical line is installed and catch-up has drained, so seq 3 is live.
+    emit(3)
+    await waitFor('live seq 3 after reconnect', () => values.length == 3)
+
+    await check('reconnect performs one fresh delayed auth', () => authCount, authBeforeReconnect + 1)
+    await check('reconnect preserves Socket.IO object identity', () => cli.hub.socket === socket, true)
+    await check('reconnect increments connectCount exactly once', () => cli.hub.connectCount(), connectCount + 1)
+    await check('catch-up then live delivery has no gap or duplicate', () => values, [1, 2, 3])
+    await check('reported seq has no gap or duplicate', () => seqs, [1, 2, 3])
+    await check('one logical client subscription survives reconnect', () =>
+        cli.client.api.subscriptions().length, 1)
+    await check('one physical server subscription after reconnect', serverSubscriberCount, 1)
+
+    sub()
+    await waitFor('subscription cleanup', () =>
+        cli.client.api.subscriptions().length == 0 && serverSubscriberCount() == 0)
+    clearTimeout(watchdog)
+    cli.close()
+    await srv.close()
+    process.exit(done() == 0 ? 0 : 1)
+}
+
+main().catch(function reportFailure(error) {
+    console.error(error)
+    process.exit(2)
+})