@loopeco/socketio/src/mixins/socketio.mixin.ts

A enhanced LoopBack's WebSocket server based on socket.io

import {Application, Binding, BindingAddress, Constructor, MixinTarget, Provider} from '@loopback/core';
import {ExpressMiddlewareFactory, ExpressRequestHandler, Middleware, MiddlewareBindingOptions} from '@loopback/express';
import {SocketIoServer} from '../socketio.server';
import {SocketIoBindings, SocketIoTags} from '../keys';
import {SocketIoMetadata} from '../decorators';
import {SocketIoComponent} from '../socketio.component';

export function SocketIoMixin<T extends MixinTarget<Application>>(superClass: T) {
  return class extends superClass {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    constructor(...args: any[]) {
      super(...args);
      this.component(SocketIoComponent);
    }

    /**
     * The main Socket server instance providing Socket connections for this application.
     */
    get socketServer(): SocketIoServer {
      return this.getSync<SocketIoServer>(SocketIoBindings.SERVER);
    }

    /**
     * Bind an Express middleware to this server context
     *
     * @example
     * ```ts
     * import myExpressMiddlewareFactory from 'my-express-middleware';
     * const myExpressMiddlewareConfig= {};
     * const myExpressMiddleware = myExpressMiddlewareFactory(myExpressMiddlewareConfig);
     * server.expressMiddleware('middleware.express.my', myExpressMiddleware);
     * ```
     * @param key - Middleware binding key
     * @param middleware - Express middleware handler function(s)
     * @param options - Middleware binding options
     *
     */
    expressMiddleware(
      key: BindingAddress,
      middleware: ExpressRequestHandler | ExpressRequestHandler[],
      options?: MiddlewareBindingOptions,
    ): Binding<Middleware>;

    /**
     * Bind an Express middleware to this server context
     *
     * @example
     * ```ts
     * import myExpressMiddlewareFactory from 'my-express-middleware';
     * const myExpressMiddlewareConfig= {};
     * server.expressMiddleware(myExpressMiddlewareFactory, myExpressMiddlewareConfig);
     * ```
     * @param middlewareFactory - Middleware module name or factory function
     * @param middlewareConfig - Middleware config
     * @param options - Options for registration
     *
     * @typeParam CFG - Configuration type
     */
    expressMiddleware<CFG>(
      middlewareFactory: ExpressMiddlewareFactory<CFG>,
      middlewareConfig?: CFG,
      options?: MiddlewareBindingOptions,
    ): Binding<Middleware>;

    expressMiddleware<CFG>(
      factoryOrKey: ExpressMiddlewareFactory<CFG> | BindingAddress<Middleware>,
      configOrHandlers: CFG | ExpressRequestHandler | ExpressRequestHandler[],
      options: MiddlewareBindingOptions = {},
    ): Binding<Middleware> {
      return this.socketServer.expressMiddleware(factoryOrKey, configOrHandlers, {
        chain: SocketIoTags.SOCKETIO_MIDDLEWARE_CHAIN,
        ...options,
      });
    }

    /**
     * Register a middleware function or provider class
     *
     * @example
     * ```ts
     * const log: Middleware = async (requestCtx, next) {
     *   // ...
     * }
     * server.middleware(log);
     * ```
     *
     * @param middleware - Middleware function or provider class
     * @param options - Middleware binding options
     */
    middleware(
      middleware: Middleware | Constructor<Provider<Middleware>>,
      options: MiddlewareBindingOptions = {},
    ): Binding<Middleware> {
      return this.socketServer.middleware(middleware, {
        chain: SocketIoTags.SOCKETIO_MIDDLEWARE_CHAIN,
        ...options,
      });
    }

    route(controllerClass: Constructor<object>, meta?: SocketIoMetadata | string | RegExp) {
      return this.socketServer.route(controllerClass, meta);
    }
  };
}