@persistica/flux-mesh 0.0.2 → 0.0.4-1

package/project.json

@@ -1,79 +0,0 @@
-{
-    "name": "persistica-flux-mesh",
-    "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-    "sourceRoot": "packages/flux/mesh/src",
-    "projectType": "library",
-    "tags": [
-        "type:npm-package",
-        "scope:any"
-    ],
-    "targets": {
-        "bun-serve": {
-            "executor": "nx:run-commands",
-            "options": {
-                "command": "bun --watch run ./packages/flux/mesh/src/main.ts"
-            }
-        },
-        "build": {
-            "executor": "nx:run-commands",
-            "options": {
-                "command": "bun run {projectRoot}/build.js",
-                "args": [
-                    "--projectRoot={projectRoot}"
-                ]
-            }
-        },
-        "serve": {
-            "executor": "@nx/js:node",
-            "defaultConfiguration": "development",
-            "dependsOn": [
-                "build"
-            ],
-            "options": {
-                "buildTarget": "persistica-flux-mesh:build",
-                "runBuildTargetDependencies": false
-            },
-            "configurations": {
-                "development": {
-                    "buildTarget": "persistica-flux-mesh:build:development"
-                },
-                "production": {
-                    "buildTarget": "persistica-flux-mesh:build:production"
-                }
-            }
-        },
-        "nx-release-publish": {
-            "options": {
-                "packageRoot": "dist/{projectRoot}"
-            }
-        },
-        "npm-publish": {
-            "executor": "nx:run-commands",
-            "options": {
-                "commands": [
-                    "npm login",
-                    "npm publish --access public"
-                ]
-            },
-            "dependsOn": [
-                "build"
-            ]
-        },
-        "bun-test": {
-            "executor": "nx:run-commands",
-            "options": {
-                "command": "bun test {projectRoot}/ --env-file=.env.e2e"
-            }
-        }
-    },
-    "release": {
-        "version": {
-            "currentVersionResolver": "git-tag",
-            "fallbackCurrentVersionResolver": "disk",
-            "preserveLocalDependencyProtocols": false,
-            "manifestRootsToUpdate": [
-                "dist/{projectRoot}"
-            ]
-        }
-    }
-}

package/src/_classes/web-rtc-client-interface.class.ts

@@ -1,79 +0,0 @@
-import type {
-    TProcessAddress,
-} from '@flux/shared/types';
-import { GlobalRPCClient2 } from '../routing/rpc/core/global-rpc-client.class';
-import {
-    type TRPCResponseCallbackFunction,
-    RPCClient,
-} from '@flux/shared/ws';
-
-export class WebRTCClient extends RPCClient<
-    'createOffer' | 'acceptOffer' | 'acceptAnswer' | 'answerAcceptedByInitiator'
-> {
-    constructor(
-        private readonly _originProcessAddress: TProcessAddress,
-        private readonly _sendToRPCServer: (
-            data: any, // ! Use 'unknown' or Bun.BufferSource (does not work)
-            compress?: boolean | undefined
-        ) => number,
-
-        // Handle the response from the RPC server
-        private readonly _handleResponseMessage: (
-            fn: TRPCResponseCallbackFunction,
-        ) => void
-    ) {
-        super(_sendToRPCServer, _handleResponseMessage);
-    }
-
-    public createOffer(): Promise<unknown> {
-        // TODO TYPE OFFER
-        return super.call(this._originProcessAddress, 'createOffer');
-    }
-
-    public acceptOfferAndCreateAnswer(
-        offer: unknown // TODO TYPE OFFER
-    ): Promise<unknown> {
-        // TODO TYOPE answer
-        return super.call(this._originProcessAddress, 'acceptOffer', offer);
-    }
-
-    public acceptAnswer(
-        answer: unknown // TODO TYPE answer
-    ): Promise<boolean> {
-        return super.call(this._originProcessAddress, 'acceptAnswer', answer);
-    }
-
-    public answerWasAccepted(answerAccepted: boolean): Promise<boolean> {
-        return super.call(
-            this._originProcessAddress,
-            'answerAcceptedByInitiator',
-            answerAccepted
-        );
-    }
-}
-
-export class GlobalWebRTCClient extends GlobalRPCClient2<
-    'createOffer' | 'acceptOffer' | 'acceptAnswer' | 'answerAcceptedByInitiator'
-> {
-    public createOffer(): Promise<unknown> {
-        // TODO TYPE OFFER
-        return super.call('createOffer');
-    }
-
-    public acceptOfferAndCreateAnswer(
-        offer: unknown // TODO TYPE OFFER
-    ): Promise<unknown> {
-        // TODO TYOPE answer
-        return super.call('acceptOffer', offer);
-    }
-
-    public acceptAnswer(
-        answer: unknown // TODO TYPE answer
-    ): Promise<boolean> {
-        return super.call('acceptAnswer', answer);
-    }
-
-    public answerWasAccepted(answerAccepted: boolean): Promise<boolean> {
-        return super.call('answerAcceptedByInitiator', answerAccepted);
-    }
-}

package/src/_routes/auth/network-authority.post.route.ts

@@ -1,74 +0,0 @@
-import type * as Bun from 'bun';
-import * as nodeURL from 'node:url';
-import { PicoLogger } from '@utils/pico-logger';
-import { generateToken } from '../../auth/auth';
-import {
-    type TNetworkId_S,
-    validateNetworkIdOrThrow,
-} from '@flux/shared/types';
-import {
-    type TFluxClientUID,
-    validateMachineUID,
-} from '@flux/shared/utils';
-
-/**
- * This route is used to authorize a network authority.
- * 
- * @returns { Promise<Response> }
- */
-export const authorizeNetworkAuthority = async (
-    request: Bun.BunRequest,
-): Promise<Response> => {
-    const urlWithParsedQuery: nodeURL.UrlWithParsedQuery = nodeURL.parse(request.url, true);
-
-    // Find the network authority to authenticate with
-    const networkIdString: string | string[] | undefined = urlWithParsedQuery.query['networkId'];
-
-    try {
-        validateNetworkIdOrThrow(networkIdString ?? '');
-    } catch (error) {
-        return new Response(
-            error instanceof Error ? error.message : 'Unknown error validating network ID',
-            {
-                status: 500,
-            },
-        );
-    }
-    const networkId: TNetworkId_S = networkIdString as TNetworkId_S;
-    const text = await request.text();
-
-    PicoLogger.log(`Received password:${text}${networkId}`, 'authorize');
-
-    console.error('TODOD: CHECK PASSWORD');
-
-    const cookies = request.cookies;
-
-    // Set a cookie with various options
-    cookies.set('user_id', '12345', {
-        maxAge: 60 * 60 * 24 * 7, // 1 week
-        httpOnly: true,
-        secure: true,
-        path: '/',
-    });
-
-    const machineUIDString: string | string[] | undefined = urlWithParsedQuery.query['machineUID'];
-    let machineUID: TFluxClientUID | undefined;
-    if (machineUIDString && validateMachineUID(machineUIDString)) {
-        machineUID = machineUIDString;
-    }
-
-    return new Response(
-        generateToken({
-            networkId,
-            isAuthority: true,
-            machineUID: machineUID,
-        }),
-        {
-            headers: {
-                'Content-Type': 'text/plain',
-                'Access-Control-Allow-Origin': '*',
-                'Set-Cookie': 'sessionId=abc123; HttpOnly; Max-Age=3600',
-            },
-        }
-    );
-};

package/src/_routes/auth/network-client.post.route.ts

@@ -1,169 +0,0 @@
-import type { BunRequest } from 'bun';
-import * as nodeURL from 'node:url';
-import {
-    type TAddress,
-    type TNetworkId_S,
-    GlobalRPCTimeoutError,
-    UnknownClientError,
-    validateAgentUIDOrThrow,
-    validateNetworkIdOrThrow,
-} from '@flux/shared/types';
-import { generateToken } from '../../auth/auth';
-import type { GlobalRPCClient } from '../../routing/rpc/core/global-rpc-client.class';
-import type { NetworkAuthorityManager } from '../../register/register-network-authority.class';
-import { retry } from '@flux/shared/utils';
-import {
-    type TFluxClientUID,
-    validateMachineUID,
-} from '@flux/shared/utils';
-
-/**
- * 
- * @param { BunRequest }                    request
- * @param { NetworkAuthorityManager }       networkAuthorityManager
- * @param { GlobalRPCClient<'authorize'> }  globalRPCClient
- * 
- * @returns { void }
- */
-export const authorizeNetworkAgent = async (
-    request: BunRequest,
-    networkAuthorityManager: NetworkAuthorityManager,
-    globalRPCClient: GlobalRPCClient<'authorize'>,
-) => {
-    const urlWithParsedQuery: nodeURL.UrlWithParsedQuery = nodeURL.parse(request.url, true);
-
-    // Find the network authority to authenticate with
-    const networkIdString: string | string[] | undefined = urlWithParsedQuery.query['networkId'];
-
-    try {
-        validateNetworkIdOrThrow(networkIdString ?? '');
-    } catch (error) {
-        return new Response(
-            error instanceof Error ? error.message : 'Unknown error validating network ID',
-            {
-                status: 500,
-            },
-        );
-    }
-    const networkId: TNetworkId_S = networkIdString as TNetworkId_S;
-
-    if (!networkId) {
-        return new Response('Missing networkId', {
-            status: 500,
-            headers: {
-                //   'Access-Control-Allow-Origin': '*',
-            },
-        });
-    }
-
-    const text = await request.text();
-
-    const contentType = request.headers
-        .get('x-flux-content-type')
-        ?.toLowerCase();
-
-    try {
-        let networkAuthorityAddress: TAddress;
-
-        const authorizedJWT: string = await retry<string>(
-            async () => {
-                networkAuthorityAddress = await networkAuthorityManager
-                    .resolveNetworkAuthorityAddressOrThrow(
-                        networkId,
-                    );
-
-                return globalRPCClient.call(
-                    networkAuthorityAddress,
-                    'authorize',
-                    `${contentType === 'application/json' ? 'json' : 'text'}:${text}`
-                );
-            },
-            (error: unknown) => {
-                if (
-                    (error instanceof UnknownClientError) ||
-                    (error instanceof GlobalRPCTimeoutError)
-                ) {
-                    networkAuthorityManager.removeUnresponsiveClient(
-                        networkId,
-                        networkAuthorityAddress,
-                    );
-
-                    return true;
-                }
-
-                return false;
-            },
-            {
-                retries: 10,
-                delayMs: 50,
-                onRetry: (
-                    attempt: number,
-                    retries: number,
-                ) => {
-                    console.log(`[authorizeNetworkAgent] Retrying... (attempt: ${attempt} of ${retries})`);
-                },
-            },
-        );
-
-        // const authorizedJWT: string = await globalRPCClient.call(
-        //     networkAuthorityAddress,
-        //     'authorize',
-        //     `${contentType === 'application/json' ? 'json' : 'text'}:${text}`
-        // );
-
-        if (authorizedJWT) {
-            const requestedAgentUidString: string | string[] | undefined = urlWithParsedQuery.query['requestedAgentUid'];
-
-            if (requestedAgentUidString) {
-                try {
-                    validateAgentUIDOrThrow(requestedAgentUidString);
-                } catch (error) {
-                    return new Response(
-                        error instanceof Error ? error.message : 'The requested agent ID is not valid',
-                        {
-                            status: 500,
-                        },
-                    );
-                }
-            }
-
-            const cookies = request.cookies;
-
-            // Set a cookie with various options
-            cookies.set('claim', authorizedJWT, {
-                maxAge: 60 * 60 * 24 * 7, // 1 week
-                httpOnly: true,
-                secure: true,
-                path: '/',
-            });
-
-            const machineUIDString: string | string[] | undefined = urlWithParsedQuery.query['machineUID'];
-            let machineUID: TFluxClientUID | undefined;
-            if (machineUIDString && validateMachineUID(machineUIDString)) {
-                machineUID = machineUIDString;
-            }
-
-            return new Response(
-                generateToken({
-                    networkId,
-                    claim: authorizedJWT,
-                    agentUID: requestedAgentUidString,
-                    machineUID: machineUID,
-                }),
-                {
-                    headers: {
-                        'Content-Type': 'text/plain',
-                        'Access-Control-Allow-Origin': '*',
-                        //   'Set-Cookie': `sessionId=abc123; HttpOnly; Max-Age=3600; signed=true; Path=/;`,
-                    },
-                }
-            );
-        }
-    } catch (error) {
-        console.error('Error authorizing:', error);
-    }
-
-    return new Response('Unauthorized', {
-        status: 500,
-    });
-};

package/src/_routes/options.route.ts

@@ -1,9 +0,0 @@
-export const OPTIONS_RESPONSE = () =>
-    new Response(null, {
-        status: 204,
-        headers: {
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-            'Access-Control-Allow-Headers': 'Content-Type, x-flux-content-type, Set-Cookie',
-        },
-    });

package/src/auth/auth.ts

@@ -1,29 +0,0 @@
-import jwt from 'jsonwebtoken';
-
-const secret = 'your-very-secure-secret'; // keep this secret safe!
-
-export const generateToken = (
-    payload: object,
-    expiresIn = 60_000 //! TODOD CHANGE TO LOW VALUE AGAINGA.. FOR DEVE.. Live for 60 seconds
-): string => {
-    return jwt.sign(payload, secret, { expiresIn });
-};
-
-export const verifyTokenOrThrow = (
-    token: unknown,
-    // callback?: VerifyCallback<JwtPayload | string>,
-): object => {
-    if (typeof token !== 'string') {
-        throw new Error('Token must be a string');
-    }
-
-    try {
-        const decoded = jwt.verify(token, secret);
-
-        return decoded as any;
-    } catch (err) {
-        console.error('Invalid or expired token', (<any>err).message);
-
-        throw new Error('Invalid or expired token');
-    }
-};

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

@@ -1,209 +0,0 @@
-import {
-    type TAddress,
-    type TChannelName,
-    type TNetworkId_S,
-    AUTHORITY_ON_CREATE_CHANNEL,
-    AUTHORITY_ON_EMPTY_CHANNEL,
-} from '@flux/shared/types';
-import { NetworkChannelHash } from '@flux/mesh/store/redis/network-channel';
-import {
-    type RedisConnection,
-    getMeshRedisConnection,
-} from '../../routing/redis/redis-connection.class';
-import type { GlobalChannelPubsub } from '../../routing/global-channel/global-channel-pubsub.class';
-
-// ! TODO Hardcoded for now, take from network config in the future
-const MAX_CHANNEL_MEMBERS = 25;
-
-interface IUsageCache {
-    networkId: TNetworkId_S;
-    usage: number;
-};
-export class NetworkChannelManager {
-    private readonly channelUsageCount: Map<TChannelName, IUsageCache> = new Map();
-    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
-    private readonly networkChannelHash: NetworkChannelHash = new NetworkChannelHash(
-        this.redisConnection,
-    );
-
-    constructor(
-        private readonly _globalChannelPubsub: GlobalChannelPubsub,
-    ) {
-        setInterval(() => {
-            for (const [channelName, usage] of this.channelUsageCount) {
-
-                if (usage.usage > 0) {
-                    this.networkChannelHash
-                        .incrementUsage(
-                            usage.networkId,
-                            channelName,
-                            usage.usage,
-                        );
-                }
-
-                this.channelUsageCount.delete(channelName);
-            }
-        }, 5_000);
-    }
-
-    /**
-     * Checks if a channel can have more members.
-     *  
-     * ! TODO Don't query the database repeatedly, implement local synced cache.
-     * 
-     * @param { TNetworkId_S } networkId
-     * @param { TChannelName } channelName
-     *
-     * @returns { Promise<boolean> }
-     */
-    public async canHaveMembers(
-        networkId: TNetworkId_S,
-        channelName: TChannelName,
-    ): Promise<boolean> {
-        const count: number = await this.networkChannelHash.readNetworkMemberCount(
-            networkId,
-            channelName,
-        );
-
-        return Promise.resolve(count < MAX_CHANNEL_MEMBERS);
-    }
-
-    /**
-     * Joins a network channel.
-     * 
-     * @param { TNetworkId_S }  networkId 
-     * @param { TChannelName }  channelName 
-     * @param { TAddress }      clientAddress
-     * 
-     * @returns { void } 
-     */
-    public joinNetworkChannel(
-        networkId: TNetworkId_S,
-        channelName: TChannelName,
-        clientAddress: TAddress,
-    ): void {
-        this.createNetworkChannelIfNotExist(
-            networkId,
-            channelName,
-        );
-
-        this.networkChannelHash.joinNetworkChannel(
-            networkId,
-            channelName,
-            clientAddress,
-        );
-    }
-
-    /**
-     * Leaves a network channel.
-     * 
-     * @param { TNetworkId_S }  networkId 
-     * @param { TChannelName }  channelName 
-     * @param { TAddress }      clientAddress
-     * 
-     * @returns { Promise<void> } 
-     */
-    public async leaveNetworkChannel(
-        networkId: TNetworkId_S,
-        channelName: TChannelName,
-        clientAddress: TAddress,
-    ): Promise<void> {
-        const membersLeft: number = await this.networkChannelHash
-            .leaveNetworkChannel(
-                networkId,
-                channelName,
-                clientAddress,
-            );
-
-        if (membersLeft === 0) {
-            this._globalChannelPubsub
-                .publish(
-                    `~/networks/${networkId}/channel-empty`,
-                    `${AUTHORITY_ON_EMPTY_CHANNEL}:${channelName}`,
-                );
-        }
-    }
-
-    /**
-     * Leaves all network channels.
-     * 
-     * @param { TNetworkId_S }          networkId
-     * @param { TAddress }              clientAddress
-     * @param { Set<TChannelName> }     channelNames
-     * 
-     * @returns { void } 
-     */
-    public leaveAllNetworkChannels(
-        networkId: TNetworkId_S,
-        clientAddress: TAddress,
-        channelNames: Set<TChannelName>,
-    ): void {
-        this.networkChannelHash.leaveAllNetworkChannels(
-            networkId,
-            clientAddress,
-            channelNames,
-        );
-    }
-
-    /**
-     * Creates a network channel if it does not exist.
-     * 
-     * @param { TNetworkId_S }  networkId
-     * @param { TChannelName }  channelName
-     * 
-     * @returns { void } 
-     */
-    private async createNetworkChannelIfNotExist(
-        networkId: TNetworkId_S,
-        channelName: TChannelName,
-    ): Promise<void> {
-        const wasCreated: boolean = await this.networkChannelHash
-            .createNetworkChannelIfNotExist(
-                networkId,
-                channelName,
-            );
-
-        if (wasCreated) {
-            this._globalChannelPubsub
-                .publish(
-                    `~/networks/${networkId}/channel-created`,
-                    `${AUTHORITY_ON_CREATE_CHANNEL}:${channelName}`,
-                );
-        }
-    }
-
-    // ****************************************************************************
-    // *** Update
-    // ****************************************************************************
-
-    /**
-     * Increases the usage count of a channel.
-     * 
-     * @param { TNetworkId_S } networkId
-     * @param { TChannelName } channelName
-     * @param { number } usage
-     * 
-     * @returns { void }
-     */
-    public increaseUsageCount(
-        networkId: TNetworkId_S,
-        channelName: TChannelName,
-        usage: number,
-    ): void {
-        const channelUsageCache: {
-            networkId: TNetworkId_S;
-            usage: number;
-        } | undefined = this.channelUsageCount.get(channelName);
-
-        this.channelUsageCount.set(
-            channelName,
-            channelUsageCache ? {
-                ...channelUsageCache,
-                usage: channelUsageCache.usage + usage,
-            } : {
-                networkId,
-                usage: usage,
-            },
-        );
-    }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export {
-    FluxMeshServer,
-} from './main';