@persistica/flux-mesh 0.0.27 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@persistica/flux-mesh",
-    "version": "0.0.27",
+    "version": "0.0.28",
     "description": "Persistica Flux Mesh",
     "type": "module",
     "keywords": [],

package/src/_managers/agent.manager.d.ts

@@ -1,15 +1,15 @@
 import { type TAddress, type TClientId } from '@flux/shared/types';
 import { RedisConnection } from '../routing/redis/redis-connection.class';
 import { TConnectedClientSocket } from '../connected-client-socket.types';
-import { NetworkAgentRedisCache } from '../register/network-agent-redis-cache.class';
+import { NetworkAgentService } from '../register/network-agent.service';
 export declare class AgentManager {
     private readonly _redisConnection;
     private readonly _clientMap;
-    private readonly _networkAgentRedisCache;
+    private readonly _networkAgentService;
     private readonly machineAddress;
     private readonly processAddress;
     private readonly _globalClientManager;
     private readonly _localAgentManager;
-    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
+    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentService: NetworkAgentService);
     kick(agentAddress: TAddress): void;
 }

package/src/_managers/local/local-agent.manager.d.ts

@@ -3,10 +3,10 @@
  */
 import type { TClientId } from '@flux/shared/types';
 import { TConnectedClientSocket } from '../../connected-client-socket.types';
-import { NetworkAgentRedisCache } from '../../register/network-agent-redis-cache.class';
+import { NetworkAgentService } from '../../register/network-agent.service';
 export declare class LocalAgentManager {
     private readonly _clientMap;
-    private readonly _networkAgentRedisCache;
-    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
+    private readonly _networkAgentService;
+    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentService: NetworkAgentService);
     kickAgent(clientId: TClientId): Promise<void>;
 }

package/src/_ws-handlers/ws-socket-close.d.ts

@@ -0,0 +1,4 @@
+import { TConnectedClientSocket } from '../connected-client-socket.types';
+import { NetworkAuthorityCache } from '../register/network-authority-cache.class';
+import { NetworkAgentService } from '../register/network-agent.service';
+export declare const onSocketClosed: (clientMap: Map<string, TConnectedClientSocket>, networkAuthorityRedisCache: NetworkAuthorityCache, networkAgentService: () => NetworkAgentService) => (ws: TConnectedClientSocket, code: number) => Promise<void>;

package/src/business-logic/channels/channel-manager.class.d.ts

@@ -1,4 +1,4 @@
-import { type TAddress, type TChannelName, type TNetworkId_S, type TSubscription_S } from '@flux/shared/types';
+import { type TAddress, type TChannelName, type TNetworkId_S, type TSubscription_S, type TClientId } from '@flux/shared/types';
 import type { GlobalChannelPubsub } from '../../routing/global-channel/global-channel-pubsub.class';
 export declare class NetworkChannelManager {
     private readonly _globalChannelPubsub;
@@ -24,6 +24,7 @@ export declare class NetworkChannelManager {
      * Leaves all network channels.
      */
     leaveAllNetworkChannels(networkId: TNetworkId_S, clientAddress: TAddress, channelNames: Set<TChannelName>): Promise<void>;
+    readChannelNamesForClientId(networkId: TNetworkId_S, clientId: TClientId): Promise<Set<TChannelName>>;
     /**
      * Increases the usage count of a channel.
      */

package/src/business-logic/processes/process.class.d.ts

@@ -1,13 +1,10 @@
 import { type TProcessAddress, type TMachineAddress } from '@flux/shared/types';
 import { RedisConnection } from '../../routing/redis/redis-connection.class';
-import { NetworkChannelManager } from '../channels/channel-manager.class';
+import { NetworkAgentService } from '../../register/network-agent.service';
 export declare class ProcessClass {
     private readonly _redisConnection;
-    private readonly _networkChannelManager;
-    private readonly networkAgentRedisRepository;
-    private readonly networkChannelService;
-    private readonly networkAgentRedisService;
-    constructor(_redisConnection: RedisConnection, _networkChannelManager: NetworkChannelManager);
+    private readonly _networkAgentService;
+    constructor(_redisConnection: RedisConnection, _networkAgentService: NetworkAgentService);
     /**
      *
      */

package/src/main.d.ts

@@ -13,6 +13,7 @@ export declare class FluxMeshServer {
     private readonly channelManager;
     private readonly agentManager;
     private readonly processClass;
+    private readonly networkAgentService;
     constructor(optionsOrPort?: (TOptions | number) | undefined);
     onReady(fn: () => void): void;
     /**

package/src/register/network-agent-redis-cache.class.d.ts

@@ -13,7 +13,7 @@ export declare class NetworkAgentRedisCache {
      * Register an agent.
      *
      * @param { TNetworkId_S } networkId - The network ID
-     * @param { TClientId } id - The client socket ID
+     * @param { TClientId } clientId - The client socket ID
      * @param { Bun.SocketAddress | null } ip - The client IP address
      * @param { TAddress } address - The client address
      * @param { object } throughput - The throughput tracking object
@@ -22,7 +22,7 @@ export declare class NetworkAgentRedisCache {
      *
      * @returns { Promise<void> }
      */
-    registerAgent(networkId: TNetworkId_S, id: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
+    registerAgent(networkId: TNetworkId_S, clientId: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
         bytes: number;
         packets: number;
     }, uid?: TAgentOwnUId, machineUID?: TFluxClientUID): Promise<void>;

package/src/register/network-agent.service.d.ts

@@ -0,0 +1,30 @@
+import type { TAddress, TClientId, TAgentOwnUId, TNetworkId_S, TChannelName } from '@flux/shared/types';
+import type { TFluxClientUID } from '@flux/shared/utils';
+import { NetworkAgentRedisCache } from './network-agent-redis-cache.class';
+import { NetworkChannelManager } from '../business-logic/channels/channel-manager.class';
+import { RedisConnection } from '../routing/redis/redis-connection.class';
+export declare class NetworkAgentService {
+    private readonly networkAgentRedisCache;
+    private readonly redisConnection;
+    private readonly networkChannelManager;
+    private readonly networkAgentRedisRepository;
+    constructor(networkAgentRedisCache: NetworkAgentRedisCache, redisConnection: RedisConnection, networkChannelManager: NetworkChannelManager);
+    /**
+     * Register an agent.
+     */
+    registerAgent(networkId: TNetworkId_S, clientId: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
+        bytes: number;
+        packets: number;
+    }, uid?: TAgentOwnUId, machineUID?: TFluxClientUID): Promise<void>;
+    /**
+     * Unregisters a network agent UID and associated data from the Redis hash.
+     */
+    unregister(clientId: TClientId, clientAddress?: TAddress, networkId?: TNetworkId_S, networkChannels?: Set<TChannelName>, clientOwnUId?: {
+        clientOwnUId: TAgentOwnUId;
+        networkId: TNetworkId_S;
+    }): Promise<void>;
+    /**
+     * Resolves the network client address by an agent's UID, using a local cache to avoid unnecessary Redis calls.
+     */
+    resolveClientAddressByUid(networkId: TNetworkId_S, clientOwnUId: TAgentOwnUId): Promise<TAddress>;
+}

package/src/register/network-authority-cache.class.d.ts

@@ -9,11 +9,12 @@ export declare class NetworkAuthorityCache {
      *
      * @param { TNetworkId_S } networkId - The network ID to register on
      * @param { TClientId } clientId - The socket ID of the authority
+     * @param { Bun.SocketAddress | null } ip - The client IP address
      * @param { TFluxClientUID } [machineUID] - Optional machine UID
      *
      * @returns { Promise<void> }
      */
-    register(networkId: TNetworkId_S, clientId: TClientId, machineUID?: TFluxClientUID): Promise<void>;
+    register(networkId: TNetworkId_S, clientId: TClientId, ip: Bun.SocketAddress | null, machineUID?: TFluxClientUID): Promise<void>;
     /**
      * Unregisters a network authority from the local network.
      *