socket-types.ts

import type { z } from 'zod';
import type { ExerciseState } from '../state.js';
import type {
    JoinParallelExerciseResponseData,
    UpdateParallelExerciseResponseData,
} from '../interfaces/parallel-exercise.js';
import type { ExerciseKey } from '../exercise-keys.js';
import type { JoinExerciseResponseDataInput } from '../interfaces/exercise.js';
import type { ExerciseAction } from '../store/action-reducers/action-reducers.js';
import type { UUID } from '../utils/uuid.js';
import type { CollectionEntityId } from '../marketplace/models/versioned-id-schema.js';
import type { Marketplace } from '../interfaces/collections.js';

export interface ServerToClientEvents {
    performAction: (action: ExerciseAction) => void;
    updateExerciseInstances: (data: UpdateParallelExerciseResponseData) => void;
    collectionUpdate: (
        data: z.input<typeof Marketplace.Collection.Events.SSEvent.schema>
    ) => void;
}

// The last argument is always expected to be the callback function. (To be able to use it in advanced typings)
export interface ClientToServerEvents {
    joinExercise: (
        payload: {
            exerciseKey: ExerciseKey;
            /** Present on fresh join; absent on reconnect. */
            clientName?: string;
            /** Present on reconnect attempt; absent on fresh join. */
            clientId?: UUID;
        },
        callback: (
            response: SocketResponse<JoinExerciseResponseDataInput>
        ) => void
    ) => void;
    proposeAction: (
        action: ExerciseAction,
        callback: (response: SocketResponse) => void
    ) => void;
    getState: (
        callback: (response: SocketResponse<ExerciseState>) => void
    ) => void;
    joinParallelExercise: (
        id: UUID,
        callback: (
            response: SocketResponse<JoinParallelExerciseResponseData>
        ) => void
    ) => void;
    controlParallelExercise: (
        action: 'pause' | 'start',
        callback: (response: SocketResponse) => void
    ) => void;
    registerCollectionListenerClient: (
        callback: (response: SocketResponse) => void
    ) => void;
    joinCollectionRoom: (
        collectionEntityId: CollectionEntityId,
        callback: (
            response: SocketResponse<
                typeof Marketplace.Collection.Events.InitialData.InputType
            >
        ) => void
    ) => void;
    leaveCollectionRoom: (
        collectionEntityId: CollectionEntityId,
        callback: (response: SocketResponse) => void
    ) => void;
}

// eslint-disable-next-line @typescript-eslint/no-empty-object-type
export interface InterServerEvents {}

// eslint-disable-next-line @typescript-eslint/no-empty-object-type
export interface SocketData {}

export type SocketResponse<T = undefined> =
    | (T extends undefined
          ? {
                readonly success: true;
            }
          : {
                readonly success: true;
                readonly payload: T;
            })
    | {
          readonly success: false;
          readonly message: string;
          readonly expected: boolean;
      };