Fis-MessageTransmission/src/interface/connector.interface.ts

import { BehaviorSubject, Observable, Subject } from "rxjs"
import { Bus, FisMessage, ReceiverProfile, TransmissionProfile, TransmitterProfile } from "./transport.interface"
import { WrappedMessage } from "../utils/message.ordering"
import { AdapterSet } from "./general.interface"

export type TYPE = {
    adapterProfile: AdapterProfile,
    transmitterProfile: TransmitterProfile,
    receiverProfile: ReceiverProfile,
    requestResponseProfile: TransmissionProfile
}

export interface AdapterProfile {
    id: string,
    transportType: Transport,
}


export interface AdapterManager {
    getAdapter(clientId: string, transportService: TransportService): AdapterSet | null
}

export interface AdaptorBase {
    connector: TransportService // this one will refer to the actual tranpsort service like websocket and so on
    connectorProfile: AdapterProfile
    connectionStateBus: Subject<ConnectionState>
    adaptorTransmissionRole: AdaptorTransmissionRole
    event: Subject<TransportEvent>

    subscribeConnectionState(): Observable<ConnectionState>
    publishConnectionState(): void
    connect(): void
    disconnect(): void
    getInfo(): AdapterProfile
    setAdapterProfile(id: string, transportType: Transport): void
}


export interface TransmitterAdapter extends AdaptorBase {
    emit(message: WrappedMessage): void
}

export interface ReceiverAdapter extends AdaptorBase {
    getMessageBus(bus: Bus): Observable<any>
}

export interface RequestResponseAdapter extends TransmitterAdapter, ReceiverAdapter {
    send(message: WrappedMessage): Observable<FisMessage>
}

export type ConnectionState = 'ONLINE' | 'OFFLINE'
export enum AdaptorTransmissionRole {
    Transmitter,
    Receiver,
    RequestResponse
}

export enum Transport {
    Websocket = `Websocket`,
    Grpc = `Grpc`,
    Http = `Http`,
    TCP = 'TCP'
}

// TO be used for transmission at the trasport level
export interface TransportMessage {
    id: string,
    dateCreated: Date,
    transport: Transport,
    target?: string,
    payload: any
}

export interface TransportEvent {
    id: string,
    event: Event,
    data: any
}

export type Event = 'Server Started' | 'New Client' | 'Client Connected' | 'Client Re-connected' | 'Client Disconnected' | `Server Disconnected` | 'New Message' | `Notification` | `New Server` | `Server Connected` | `New Transport` | 'New Adapter' | 'Re-Flush'

export interface TransportService {
    getInfo(): Transport
    emit(message: TransportMessage): void
    subscribe(): Observable<TransportEvent> //all messages and whatever event will go through this, easier to implemnet across different transport protocol
}

export interface Info {
    transport: Transport
}

export interface ClientObject {
    id: string,
    dateCreated: Date,
    connectionState: BehaviorSubject<ConnectionState>
}