chad/server/types/socket.ts

import type { types } from 'mediasoup'
import type { RemoteSocket, Server, Socket } from 'socket.io'
import type { ChannelPublicDTO } from '../dto/channel.dto.ts'
import type { ChannelModel, UserModel } from '../prisma/generated/client/models.ts'

export interface ServerInfo {
  owner_id: UserModel['id']
  channels: ChannelPublicDTO[]
  rtpCapabilities: types.RtpCapabilities
}

export interface ChadClient {
  socketId: string
  userId: UserModel['id']
  username: UserModel['username']
  displayName: UserModel['displayName']
  inputMuted: boolean
  outputMuted: boolean
  currentChannelId: ChannelModel['id']
}

export interface ProducerShort {
  producerId: types.Producer['id']
  kind: types.MediaKind
}

export interface ErrorCallbackResult {
  error: string
}

export interface SuccessCallbackResult {
  ok: true
}

export type EventCallback<T = SuccessCallbackResult> = (result: T | ErrorCallbackResult) => void
export type EventCallbackResult<T = SuccessCallbackResult> = Parameters<EventCallback<T>>[0]

type LastArg<T extends any[]> = T extends [...any[], infer Last] ? Last : T extends [infer Only] ? Only : never

export type ExtractCallbackPayload<
  T,
  Fallback = EventCallbackResult,
>
  = T extends (...args: infer Args) => any
    ? LastArg<Args> extends (...inner: infer CallbackArgs) => any
      ? CallbackArgs extends [infer First, ...any[]]
        ? First
        : Fallback
      : Fallback
    : Fallback

export interface ClientToServerEvents {
  'webrtc:get-rtp-capabilities': (
    cb: EventCallback<types.RtpCapabilities>
  ) => void
  'webrtc:create-transport': (
    options: {
      producing: boolean
      consuming: boolean
    },
    cb: EventCallback<Pick<types.WebRtcTransport, 'id' | 'iceParameters' | 'iceCandidates' | 'dtlsParameters'>>
  ) => void
  'webrtc:connect-transport': (
    options: {
      transportId: types.WebRtcTransport['id']
      dtlsParameters: types.WebRtcTransport['dtlsParameters']
    },
    cb: EventCallback
  ) => void
  'webrtc:produce': (
    options: {
      transportId: types.WebRtcTransport['id']
      kind: types.MediaKind
      rtpParameters: types.RtpParameters
      appData: { source: 'share' | string }
    },
    cb: EventCallback<{ id: types.Producer['id'] }>
  ) => void
  'webrtc:close-producer': (
    options: {
      producerId: types.Producer['id']
    },
    cb: EventCallback
  ) => void
  'webrtc:pause-producer': (
    options: {
      producerId: types.Producer['id']
    },
    cb: EventCallback
  ) => void
  'webrtc:resume-producer': (
    options: {
      producerId: types.Producer['id']
    },
    cb: EventCallback
  ) => void
  'webrtc:pause-consumer': (
    options: {
      consumerId: types.Consumer['id']
    },
    cb: EventCallback
  ) => void
  'webrtc:resume-consumer': (
    options: {
      consumerId: types.Consumer['id']
    },
    cb: EventCallback
  ) => void
  'webrtc:update-client': (
    options: Partial<Pick<ChadClient, 'inputMuted' | 'outputMuted'>>,
    cb: EventCallback<ChadClient>
  ) => void

  'channel:join': (
    options: { channelId: ChannelModel['id'] },
    cb: EventCallback<{ channel: ChannelPublicDTO, clients: ChadClient[] }>
  ) => void
}

export interface ServerToClientEvents {
  'webrtc:authenticated': (arg: ServerInfo) => void
  'webrtc:producers': (arg: ProducerShort[]) => void
  'webrtc:new-consumer': (
    arg: {
      socketId: string
      producerId: types.Producer['id']
      id: types.Consumer['id']
      kind: types.MediaKind
      rtpParameters: types.RtpParameters
      type: types.ConsumerType
      appData: types.Producer['appData']
      producerPaused: types.Consumer['producerPaused']
    },
    cb: EventCallback
  ) => void
  'webrtc:peer-closed': (arg: string) => void
  'webrtc:consumer-closed': (arg: { consumerId: string }) => void
  'webrtc:consumer-paused': (arg: { consumerId: string }) => void
  'webrtc:consumer-resumed': (arg: { consumerId: string }) => void
  'webrtc:consumer-score': (arg: { consumerId: string, score: types.ConsumerScore }) => void
  'webrtc:client-changed': (clientId: ChadClient['socketId'], client: ChadClient) => void
  'webrtc:speaking-peers': (arg: { clientId: ChadClient['socketId'], volume: types.AudioLevelObserverVolume['volume'] }[]) => void
  'webrtc:active-speaker': (clientId?: ChadClient['socketId']) => void

  'channel:user-joined': (arg: { channelId: string, client: ChadClient }) => void
  'channel:user-left': (arg: { channelId: string, clientId: string }) => void
  'channel:deleted': (arg: { channelId: string }) => void
  'channel:created': (arg: ChannelPublicDTO) => void
  'channel:updated': (arg: ChannelPublicDTO) => void
  'channel:force-switch': (arg: { channelId: string }) => void
}

export interface InterServerEvent {}

export interface SocketData {
  joined: boolean
  userId: UserModel['id']
  username: UserModel['username']
  displayName: UserModel['displayName']
  inputMuted: boolean
  outputMuted: boolean
  rtpCapabilities: types.RtpCapabilities
  transports: Map<types.WebRtcTransport['id'], types.WebRtcTransport>
  producers: Map<types.Producer['id'], types.Producer>
  consumers: Map<types.Consumer['id'], types.Consumer>
}

export type ChadSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvent, SocketData>
export type ChadRemoteSocket = RemoteSocket<ServerToClientEvents, SocketData>

export type SomeSocket = ChadSocket | ChadRemoteSocket

export type SocketServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvent, SocketData>