@loopeco/socketio/src/middleware.ts

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

import {BindingTemplate, Constructor, Context, Provider} from '@loopback/core';
import {
  asMiddleware,
  createMiddlewareBinding,
  invokeMiddleware,
  InvokeMiddlewareOptions,
  Middleware,
  MiddlewareBindingOptions,
  registerMiddleware,
} from '@loopback/express';
import {SocketIoConnectionContext, SocketIoConnectionHandler} from './types';
import {SocketIoTags} from './keys';

/**
 * Template function for middleware bindings
 * @param options - Options to configure the binding
 */
export function asMiddlewareForSocketIo(options: MiddlewareBindingOptions = {}): BindingTemplate {
  return asMiddleware({
    chain: SocketIoTags.SOCKETIO_MIDDLEWARE_CHAIN,
    ...options,
  });
}

/**
 * Bind the middleware function or provider class to the context
 * @param ctx - Context object
 * @param middleware - Middleware function or provider class
 * @param options - Middleware binding options
 */
export function registerMiddlewareForSocketIo(
  ctx: Context,
  middleware: Middleware | Constructor<Provider<Middleware>>,
  options: MiddlewareBindingOptions,
) {
  return registerMiddleware(ctx, middleware, {
    chain: SocketIoTags.SOCKETIO_MIDDLEWARE_CHAIN,
    ...options,
  });
}

/**
 * Create a binding for the middleware provider class
 *
 * @param middlewareProviderClass - Middleware provider class
 * @param options - Options to create middleware binding
 *
 */
export function createMiddlewareBindingForSocketIo(
  middlewareProviderClass: Constructor<Provider<Middleware>>,
  options: MiddlewareBindingOptions = {},
) {
  return createMiddlewareBinding(middlewareProviderClass, {
    chain: SocketIoTags.SOCKETIO_MIDDLEWARE_CHAIN,
    ...options,
  });
}

/**
 * An adapter function to create an SocketIo middleware handler to discover and
 * invoke registered LoopBack-style middleware in the context.
 * @param ctx - Context object to discover registered middleware
 * @param options - Options for middleware invoking
 */
export function toSocketIoMiddleware(ctx: Context, options?: InvokeMiddlewareOptions): SocketIoConnectionHandler {
  return async (socket, next) => {
    const connCtx = new SocketIoConnectionContext(socket, ctx);

    try {
      const result = await invokeMiddleware(connCtx, {
        chain: SocketIoTags.SOCKETIO_MIDDLEWARE_CHAIN,
        ...options,
      });
      if (result !== connCtx.response) {
        next();
      }
    } catch (err) {
      next(err);
    }
  };
}