@persistica/flux-mesh 0.0.2 → 0.0.3

package/src/routing/redis/network-agent.redis.ts

@@ -1,135 +0,0 @@
-/**
- * Register information on a specific network agent.
- */
-import type { RedisClient } from 'bun';
-import type {
-    TAddress,
-    TClientId,
-    TAgentOwnUId,
-    TNetworkId_S,
-} from '@flux/shared/types';
-import { NetworkAgentRedisSortedSet } from './hash/network-agent.redis.sorted-set';
-
-export class NetworkAgentRedis {
-    private readonly networkAgentRedisSortedSet: NetworkAgentRedisSortedSet;
-    private readonly cashedDataUsage: Map<string, number> = new Map();
-
-    constructor(
-        private readonly client: RedisClient,
-    ) {
-        this.networkAgentRedisSortedSet = new NetworkAgentRedisSortedSet(client);
-
-        // Update the network agent data usage regularly
-        setInterval(this.pushDataUsage.bind(this), 3_000);
-    }
-
-    /**
-     * Registers a network agent in the sorted set.
-     * 
-     * @param { TNetworkId_S } networkId
-     * @param { TClientId } socketId
-     * 
-     * @returns { Promise<void> }
-     */
-    public async registerNetworkAgent(
-        networkId: TNetworkId_S,
-        clientId: TAddress,
-        socketId: TClientId,
-        uid: TAgentOwnUId,
-    ): Promise<void> {
-        const key: string = `networks/${networkId}/agents/${socketId}`;
-
-        await this.client.hmset(key, [
-            'data-usage',
-            '0',
-
-            'clientId',
-            clientId,
-
-            'name',
-            uid,
-
-            'registerAt',
-            new Date().toISOString(),
-        ]);
-
-        await this.client.expire(key, 500);
-
-        await this.networkAgentRedisSortedSet
-            .registerAgent(
-                networkId,
-                socketId,
-            );
-    }
-
-    /**
-     * Unregisters a network agent from the sorted set.
-     * 
-     * @param { TNetworkId_S } networkId
-     * @param { TClientId } socketId
-     * 
-     * @returns { Promise<number> }
-     */
-    public async unregisterNetworkAgent(
-        networkId: TNetworkId_S,
-        socketId: TClientId,
-    ): Promise<number> {
-        const key: string = `networks/${networkId}/agents/${socketId}`;
-
-        await this.client.hmset(key, [
-            'unregisteredAt',
-            new Date().toISOString(),
-        ]);
-
-        return await this.networkAgentRedisSortedSet
-            .unregisterAgent(
-                networkId,
-                socketId,
-            );
-    }
-
-    /**
-     * 
-     * @param socketId 
-     * @param usage
-     * 
-     * @returns { void }
-     */
-    public registerDataUsage(
-        networkId: TNetworkId_S,
-        socketId: TClientId,
-        usage: number,
-    ): void {
-        const key: string = `networks/${networkId}/agents/${socketId}`;
-
-        const cashedDataUsage: number | undefined = this.cashedDataUsage.get(socketId);
-
-        if (cashedDataUsage === undefined) {
-            this.cashedDataUsage.set(key, usage);
-        } else {
-            this.cashedDataUsage.set(key, usage + cashedDataUsage);
-        }
-    }
-
-    /**
-     * Pushes the data usage to the Redis server.
-     * 
-     * @returns { Promise<void> }
-     */
-    private async pushDataUsage(
-
-    ): Promise<void> {
-
-        for (const [redisKey, usage] of this.cashedDataUsage) {
-            await this.client
-                .hincrby(
-                    redisKey,
-                    'data-usage',
-                    usage,
-                );
-
-            this.cashedDataUsage.delete(redisKey);
-        }
-
-    }
-}

package/src/routing/redis/redis-connection.class.ts

@@ -1,261 +0,0 @@
-import {
-    type TRedisEventChannel,
-    BunRedisClient,
-    BunRedisPubSub,
-} from '@core/redis/bun';
-import type { TAddress, TClientId, TProcessAddress } from '@flux/shared/types';
-import { NetworkAuthorityRedisSortedSet } from '@flux/mesh/store/redis/network-authority';
-import { NetworkAgentRedisService } from '@flux/mesh/store/redis/network-agent';
-import type { TGlobalChannel } from '../global-channel/global-channel-pubsub.class';
-
-let redisConnection: RedisConnection | undefined;
-
-if (!process.env['FLUX_MESH_REDIS_URL']) {
-    throw new Error('Missing FLUX_MESH_REDIS_URL in .env');
-}
-
-/**
- * Singleton function to get the Redis connection
- *
- * @returns
- */
-export const getMeshRedisConnection = (
-    connectionString?: string,
-) => {
-    // We have to read the env variable here, because otherwise it can't be modified in tests
-    redisConnection ??= new RedisConnection(process.env['FLUX_MESH_REDIS_URL'] as string);
-
-    return redisConnection;
-};
-
-export type MessageCallback = (message: string, channel?: string) => unknown;
-
-export class RedisConnection {
-    // Dedicated client for handling hash
-    private readonly cacheClient: BunRedisClient;
-
-    // Dedicated clients for handling pub/sub
-    private readonly pubSub: BunRedisPubSub;
-
-    public readonly networkAuthoritySet: NetworkAuthorityRedisSortedSet;
-    public readonly networkAgentRedisService: NetworkAgentRedisService;
-
-    // Wrapper to not expose BunRedisClient functions
-    public readonly hash;
-
-    constructor(
-        private readonly url: string,
-    ) {
-        this.cacheClient = new BunRedisClient({
-            url: this.url,
-            socket: {
-                reconnectStrategy: (
-                    retries: number,
-                ) => {
-                    // if (retries > 10) {
-                    //     console.error('❌ Redis reconnect failed after 10 attempts.');
-                    //     return new Error('Redis reconnect limit reached');
-                    // }
-
-                    console.warn(`🔄 Redis reconnection attempt #${retries}`);
-
-                    // Backoff in ms
-                    return Math.min(retries * 100, 3_000);
-                },
-            },
-        });
-
-        try {
-            this.cacheClient.connect();
-        } catch {
-            console.log('caught');
-        }
-
-        this.cacheClient
-            .on('error', (error) => {
-                console.error('❌ Redis client error:', error.message);
-
-                // Socket closed unexpectedly
-                // Failed to connect
-            })
-            .on('reconnecting', () => {
-                console.log('🔄 Redis reconnecting...');
-            })
-            .on('ready', () => {
-                console.log('✅ Redis client ready');
-            })
-            .on('end', () => {
-                console.warn('🚫 Redis connection closed');
-            });
-
-        this.networkAuthoritySet = new NetworkAuthorityRedisSortedSet(this.cacheClient.getClient());
-        this.networkAgentRedisService = new NetworkAgentRedisService(this.cacheClient.getClient());
-
-        // *** Create Redis subscriber
-        this.pubSub = new BunRedisPubSub(
-            {
-                url: this.url,
-                socket: {
-                    reconnectStrategy: (
-                        retries: number,
-                    ) => {
-                        console.warn(`🔄 Redis reconnection attempt #${retries}`);
-
-                        // Backoff in ms
-                        return Math.min(retries * 100, 3_000);
-                    },
-                },
-            });
-
-        this.pubSub
-            .connect()
-            .catch(() => console.log('pubsub connection failed'));
-
-        // Dedicated client
-        const hashClient = this.cacheClient.getClient();
-
-        this.hash = {
-            sadd: hashClient.sadd.bind(hashClient),
-            hmset: hashClient.hmset.bind(hashClient),
-            smembers: hashClient.smembers.bind(hashClient),
-            srem: hashClient.srem.bind(hashClient),
-            scard: hashClient.scard.bind(hashClient),
-            del: hashClient.del.bind(hashClient),
-            hincrby: hashClient.hincrby.bind(hashClient),
-            hmget: hashClient.hmget.bind(hashClient),
-            expire: hashClient.expire.bind(hashClient),
-        };
-    }
-
-    // ****************************************************************************
-    // *** Publish To All Channels
-    // ****************************************************************************
-
-    /**
-     * 
-     * @param { TProcessAddress }   skipProcessAddress
-     * @param { TGlobalChannel  }   channel
-     * @param { string }            message
-     * 
-     * @returns { Promise<void> }
-     */
-    public async publishWebsocketChannelEvent(
-        skipProcessAddress: TProcessAddress,
-        channel: TGlobalChannel,
-        message: string,
-    ): Promise<void> {
-        try {
-            await this.pubSub.publish(`~${channel}`, `${skipProcessAddress}:${message}`);
-        } catch {
-            console.error(`Publish failed on global channel event: '${channel}'`);
-        }
-    }
-
-    /**
-     * 
-     * @returns { void }
-     */
-    public async subscribeWebsocketChannelEvent(
-        callback: (
-            channel: TGlobalChannel,
-            skipProcessAddress: TProcessAddress,
-            message: string,
-        ) => unknown,
-    ): Promise<void> {
-        try {
-            await this.pubSub.subscribe('~*', (
-                message: string,
-                preFixedChannel: TRedisEventChannel,
-            ) => {
-                const index = message.indexOf(':');
-
-                const [skipProcessAddress, message_] = index !== -1
-                    ? [message.slice(0, index), message.slice(index + 1)]
-                    : [message, ''];
-
-                callback(
-                    preFixedChannel.slice(1) as TGlobalChannel,
-                    skipProcessAddress as TProcessAddress,
-                    message_,
-                );
-            });
-        } catch {
-            console.log('Error caught while subscribing to websocket channel event globally');
-        }
-    }
-
-    // ****************************************************************************
-    // *** Publish Directly to Address
-    // ****************************************************************************
-
-    /**
-     * 
-     * @param { TAddress | TProcessAddress }    address
-     * @param { string }                        message
-     * 
-     * @returns { Promise<void> }
-     */
-    public async directPublish(
-        address: TAddress | TProcessAddress,
-        message: string,
-    ): Promise<void> {
-        try {
-            await this.pubSub.publish(address, message);
-        } catch {
-            console.error(`Publish failed on address: ${address}`);
-        }
-    }
-
-    public subscribe(
-        channelId: TProcessAddress | TClientId,
-        callback: MessageCallback
-    ): void {
-        try {
-            const redisCallback = (message: string) => callback(message);
-
-            this.pubSub.subscribe(channelId, redisCallback);
-        } catch {
-            console.log('error caught #2');
-        }
-    }
-
-    public unsubscribe(
-        channelId: string,
-        callback: MessageCallback,
-    ): void {
-        try {
-            this.pubSub.unsubscribe(channelId, callback);
-        } catch {
-            console.log('error caught #1');
-        }
-    }
-
-    public async setConnected(
-        address: string,
-    ): Promise<void> {
-        await this.hash.hmset(`machines/processes/${address}`, [
-            'status', 'connected',
-            'updatedAt', new Date().toISOString(),
-        ]);
-
-        await this.hash.expire(`machines/processes/${address}`, 5);
-    }
-
-    public async setDisconnected(
-        _address: string,
-    ): Promise<void> {
-        // !TODO
-    }
-
-    /**
-     * Disconnects the Redis cache and pub/sub.
-     * 
-     * @returns { void }
-     */
-    public disconnect(
-
-    ): void {
-        this.cacheClient.disconnect();
-        this.pubSub.disconnect();
-    }
-}

package/src/routing/rpc/core/global-rpc-client.class.ts

@@ -1,215 +0,0 @@
-/**
- * The class to handling the *calling* side of the RPC.
- */
-
-import {
-    type TAddress,
-    type TProcessAddress,
-    GlobalRPCTimeoutError,
-    RPC_REQUEST,
-} from '@flux/shared/types';
-import type {
-    TCallback,
-    RPCRequest,
-    RPCResponse,
-} from '@flux/shared/ws';
-import type { OutgoingMessageRouter } from '../../outgoing-message-router.class';
-import type { ProcessMessageRouter } from '../../process-message-router.class';
-import { readProcessAddress } from '../../addressing.utils';
-
-export class GlobalRPCClient<TMethods> {
-    // TODO OD IS USED TO ROUTE THE MESSAGE; SO MAKE GLOBALLY UNIQUE IN THE FUTURE!!!
-    private requestId: number = 0; // Math.floor(Math.random() * 100_000);
-
-    // Success and error callbacks for each request.
-    private readonly pendingRequests: Map<number, [TCallback, TCallback]> =
-        new Map();
-
-    private readonly processAddress: TProcessAddress = readProcessAddress();
-
-    constructor(
-        private readonly _outgoingMessageRouter: OutgoingMessageRouter,
-        private readonly _processMessageRouter: ProcessMessageRouter,
-    ) {
-        this._processMessageRouter.subscribe((message: string): void => {
-            const message_: RPCResponse = JSON.parse(
-                message.substring(message.indexOf(':') + 1)
-            ) as RPCResponse;
-
-            this.handleResponseMessage(message_);
-        });
-    }
-
-    /**
-     * Calls a function on the other side.
-     *
-     * @param { TAddress } rpcServerClientAddress
-     * @param { TMethods } method
-     *
-     * @returns { Promise<any> }
-     */
-    public call(
-        rpcServerClientAddress: TAddress,
-        method: TMethods,
-        ...params: any
-    ): Promise<any> {
-        const id: number = this.requestId++;
-
-        const rpcRequest: RPCRequest<TMethods> = {
-            id,
-            originProcessAddress: this.processAddress,
-            method,
-            params,
-        };
-
-        return new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, [resolve, reject]);
-
-            try {
-                this._outgoingMessageRouter.message(
-                    rpcServerClientAddress,
-                    `${RPC_REQUEST}:${JSON.stringify(rpcRequest)}`
-                );
-            } catch (error) {
-                if (this.pendingRequests.get(id)) {
-                    this.pendingRequests.delete(id);
-                    reject(error instanceof Error ? error : new Error(error as string));
-                }
-            }
-
-            setTimeout(() => {
-                if (this.pendingRequests.get(id)) {
-                    this.pendingRequests.delete(id);
-                    reject(new GlobalRPCTimeoutError(method as string));
-                }
-            }, 5_000);
-        });
-    }
-
-    /**
-     * Handles the response from the server.
-     *
-     * @param { RPCResponse }   response
-     *
-     * @returns { boolean }
-     */
-    private handleResponseMessage(
-        response: RPCResponse,
-    ): void {
-        const cb: [TCallback, TCallback] | undefined = this.pendingRequests.get(
-            response.id
-        );
-
-        if (cb) {
-            this.pendingRequests.delete(response.id);
-
-            if (response.error) {
-                cb[1](response.error);
-
-                return;
-                // throw new Error(response.error);
-            }
-
-            cb[0](response.result);
-        }
-    }
-}
-
-export class GlobalRPCClient2<TMethods> {
-    // TODOOD IS USED TO ROUTE THE MESSAGE; SO MAKE GLOBALLY UNIQWUE IN THE FUTURE!!!
-    private requestId: number = 0; // Math.floor(Math.random() * 100_000);
-
-    // Success and error callbacks for each request.
-    private readonly pendingRequests: Map<number, [TCallback, TCallback]> =
-        new Map();
-
-    private readonly processAddress: TProcessAddress = readProcessAddress();
-
-    constructor(
-        private readonly _rpcServerClientAddress: TAddress,
-        private readonly _outgoingMessageRouter: OutgoingMessageRouter,
-        private readonly _processMessageRouter: ProcessMessageRouter
-    ) {
-        this._processMessageRouter.subscribe((message: string): void => {
-            const message_: RPCResponse = JSON.parse(
-                message.substring(message.indexOf(':') + 1)
-            ) as RPCResponse;
-
-            this.handleResponseMessage(message_);
-        });
-    }
-
-    /**
-     * Calls a function on the other side.
-     *
-     * @param { TAddress } rpcServerClientAddress
-     * @param { TMethods } method
-     *
-     * @returns { Promise<any> }
-     */
-    public call(
-        method: TMethods,
-        ...params: any
-    ): Promise<any> {
-        const id: number = this.requestId++;
-
-        const rpcRequest: RPCRequest<TMethods> = {
-            id,
-            originProcessAddress: this.processAddress,
-            method,
-            params,
-        };
-
-        return new Promise((resolve, reject) => {
-
-            this.pendingRequests.set(id, [resolve, reject]);
-
-            try {
-                this._outgoingMessageRouter.message(
-                    this._rpcServerClientAddress,
-                    `${RPC_REQUEST}:${JSON.stringify(rpcRequest)}`
-                );
-            } catch (error) {
-                if (this.pendingRequests.get(id)) {
-                    this.pendingRequests.delete(id);
-                    reject(error instanceof Error ? error : new Error(error as string));
-                }
-            }
-
-            setTimeout(() => {
-                if (this.pendingRequests.get(id)) {
-                    this.pendingRequests.delete(id);
-                    reject(new GlobalRPCTimeoutError(method as string));
-                }
-            }, 5_000);
-        });
-    }
-
-    /**
-     * Handles the response from the server.
-     *
-     * @param { RPCResponse }   response
-     *
-     * @returns { boolean }
-     */
-    private handleResponseMessage(
-        response: RPCResponse,
-    ): void {
-        const cb: [TCallback, TCallback] | undefined = this.pendingRequests.get(
-            response.id
-        );
-
-        if (cb) {
-            this.pendingRequests.delete(response.id);
-
-            if (response.error) {
-                cb[1](response.error);
-
-                return;
-                // throw new Error(response.error);
-            }
-
-            cb[0](response.result);
-        }
-    }
-}

package/src/test.spec.ts

@@ -1,7 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-
-describe('should have a test', () => {
-    it('should be true', () => {
-        expect(true).toBe(true);
-    });
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-    "extends": "../../../tsconfig.base.json",
-    "compilerOptions": {
-        "module": "NodeNext",
-        "forceConsistentCasingInFileNames": true,
-        "strict": true,
-        "importHelpers": true,
-        "noImplicitOverride": true,
-        "noImplicitReturns": true,
-        "noFallthroughCasesInSwitch": true,
-        "noPropertyAccessFromIndexSignature": true,
-        "lib": [
-            "es2021"
-        ]
-    },
-    "files": [],
-    "include": [],
-    "references": [
-        {
-            "path": "./tsconfig.lib.json"
-        }
-    ]
-}

package/tsconfig.lib.json

@@ -1,20 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "../../../dist/out-tsc",
-        "declaration": true,
-        "types": [
-            "node"
-        ],
-        "target": "ESNext",
-        "moduleResolution": "bundler",
-        "module": "EsNext"
-    },
-    "include": [
-        "src/**/*.ts"
-    ],
-    "exclude": [
-        "src/**/*.spec.ts",
-        "src/**/*.test.ts"
-    ]
-}