@rytass/bpm-core-nestjs-module 0.5.0 → 0.5.1

package/src/lib/bpm/bpm-root.module.ts

@@ -1,320 +0,0 @@
-import {
-  DynamicModule,
-  InjectionToken,
-  Module,
-  Provider,
-  Type,
-} from '@nestjs/common';
-import { ModuleMetadata } from '@nestjs/common/interfaces';
-import { BPMRootAttachmentOptions } from '../attachment/attachment-options';
-import { AttachmentModule } from '../attachment/attachment.module';
-import { AttachmentStorage } from '../attachment/attachment-storage.token';
-import { BPMAuthModule } from '../bpm-auth/bpm-auth.module';
-import {
-  BPMAuthModuleAsyncOptions,
-  BPMAuthModuleOptions,
-} from '../bpm-auth/bpm-auth.options';
-import { DelegationModule } from '../delegation/delegation.module';
-import { FormModule } from '../form/form.module';
-import { BPMRootIdentityOptions } from '../identity/identity-options';
-import { IdentityModule } from '../identity/identity.module';
-import { BPMMemberResolver } from '../identity/member-resolver.interface';
-import { NotificationModule } from '../notification/notification.module';
-import { NotificationOptionsModule } from '../notification/notification-options.module';
-import { BPMRootNotificationOptions } from '../notification/notification-options';
-import { OrganizationModule } from '../organization/organization.module';
-import { BPMRootSignatureOptions } from '../signature/signature-options';
-import { SignatureModule } from '../signature/signature.module';
-import { TemplateModule } from '../template/template.module';
-import { WorkflowEngineModule } from '../workflow-engine/workflow-engine.module';
-import { BPMWorkflowServiceTaskDispatcher } from '../workflow-engine/workflow-service-task-dispatcher.token';
-
-type BPMModuleImport = DynamicModule | Type<unknown>;
-
-export interface BPMRootModuleOptions
-  extends
-    Pick<ModuleMetadata, 'imports'>,
-    BPMRootAttachmentOptions,
-    BPMRootIdentityOptions,
-    BPMRootNotificationOptions,
-    BPMRootSignatureOptions {
-  /**
-   * Host-provided storage adapter for BPM attachments.
-   *
-   * When omitted, BPM stores attachments through the local
-   * `@rytass/storages-adapter-local` adapter under `.storage/attachments`.
-   * Hosts can replace this provider with any `@rytass/storages` compatible
-   * adapter such as MinIO, S3, or GCS.
-   */
-  readonly attachmentStorageProvider?: Provider<AttachmentStorage>;
-
-  /**
-   * Factory that resolves the current BPM auth context from NestJS execution
-   * context.
-   *
-   * BPM guards, GraphQL decorators, and domain services use this callback to
-   * identify the current member and organization context. When omitted, BPM
-   * operations that require authentication will not receive a host session.
-   */
-  readonly authContextFactory?: BPMAuthModuleOptions['contextFactory'];
-
-  /**
-   * Host-provided member resolver provider.
-   *
-   * BPM uses this provider to resolve member metadata, organization identity,
-   * display names, and approver candidates without coupling
-   * `@rytass/bpm-core-nestjs-module` to a specific external identity system.
-   */
-  readonly memberResolverProvider: Provider<BPMMemberResolver>;
-
-  /**
-   * Host-provided dispatcher for executable workflow service tasks.
-   *
-   * When omitted, BPM sends WEBHOOK service tasks with the built-in `fetch`
-   * dispatcher. Wrapper apps can replace this provider to add auth headers,
-   * request signing, retry queues, or an outbound integration bus.
-   */
-  readonly workflowServiceTaskDispatcherProvider?: Provider<BPMWorkflowServiceTaskDispatcher>;
-}
-
-export interface BPMRootModuleAsyncFactoryOptions
-  extends
-    BPMRootAttachmentOptions,
-    BPMRootIdentityOptions,
-    BPMRootNotificationOptions,
-    BPMRootSignatureOptions {
-  /**
-   * Factory that resolves the current BPM auth context from NestJS execution
-   * context.
-   *
-   * BPM guards, GraphQL decorators, and domain services use this callback to
-   * identify the current member and organization context. When omitted, BPM
-   * operations that require authentication will not receive a host session.
-   */
-  readonly authContextFactory?: BPMAuthModuleOptions['contextFactory'];
-}
-
-export interface BPMRootModuleAsyncOptions extends Pick<
-  ModuleMetadata,
-  'imports'
-> {
-  /**
-   * Controller mount path used by the BPM attachment endpoints.
-   *
-   * Set at module wiring time because Nest reads controller path metadata
-   * synchronously when the application starts. Async factories cannot drive
-   * this value; only static URL routing decisions should set it. Defaults to
-   * `/attachments`.
-   */
-  readonly attachmentRoutePrefix?: string | null;
-
-  /**
-   * Host-provided storage adapter for BPM attachments.
-   *
-   * This provider is static at module wiring time. If secrets are required,
-   * use a Nest provider with `useFactory` / `inject` here.
-   */
-  readonly attachmentStorageProvider?: Provider<AttachmentStorage>;
-
-  /**
-   * Providers injected into `useFactory`.
-   *
-   * This is typically used to read Vault-backed SMTP, webhook, and auth
-   * settings before constructing the flattened BPM root options.
-   */
-  readonly inject?: readonly InjectionToken[];
-
-  /**
-   * Host-provided member resolver provider.
-   *
-   * BPM uses this provider to resolve member metadata, organization identity,
-   * display names, and approver candidates without coupling
-   * `@rytass/bpm-core-nestjs-module` to a specific external identity system.
-   */
-  readonly memberResolverProvider: Provider<BPMMemberResolver>;
-
-  /**
-   * Host-provided dispatcher for executable workflow service tasks.
-   *
-   * This provider is static at module wiring time. If secrets are required,
-   * use a Nest provider with `useFactory` / `inject` here.
-   */
-  readonly workflowServiceTaskDispatcherProvider?: Provider<BPMWorkflowServiceTaskDispatcher>;
-
-  /**
-   * Async factory returning BPM root options.
-   *
-   * The returned object intentionally keeps all BPM settings flat at the root
-   * level, for example `authContextFactory`, `notificationEmailSmtpHost`, and
-   * `notificationSlaSchedulerEnabled`.
-   */
-  readonly useFactory: (
-    ...args: readonly unknown[]
-  ) =>
-    | BPMRootModuleAsyncFactoryOptions
-    | Promise<BPMRootModuleAsyncFactoryOptions>;
-}
-
-/**
- * Aggregate entry point that wires every BPM domain module
- * (`BPMAuthModule`, `IdentityModule`, `OrganizationModule`, `FormModule`,
- * `TemplateModule`, `WorkflowEngineModule`, `DelegationModule`,
- * `NotificationModule`, `SignatureModule`, `AttachmentModule`) into a
- * NestJS host application.
- *
- * Hosts call `forRoot` or `forRootAsync` once from their root `AppModule`.
- * BPMCore does **not** own login, GraphQL setup, TypeORM bootstrap, or
- * Vault loading — those remain the host's responsibility. See the
- * package README sections "Embedding & auth", "Organization data
- * ownership", and "Consumer quickstart" for the full contract.
- *
- * The host must avoid Nest's `app.setGlobalPrefix(...)`; BPM controllers
- * mount at relative paths driven by their respective options (notably
- * `attachmentRoutePrefix`).
- *
- * @example
- * ```ts
- * BPMRootModule.forRoot({
- *   authContextFactory: readBPMAuthContextFromGqlContext,
- *   memberResolverProvider: {
- *     provide: BPM_MEMBER_RESOLVER,
- *     useClass: HostMemberResolver,
- *   },
- *   attachmentPublicBaseUrl: process.env.BPM_PUBLIC_BASE_URL,
- *   attachmentSignedUrlSecret: process.env.BPM_ATTACHMENT_SIGNING_SECRET,
- * });
- * ```
- */
-@Module({})
-export class BPMRootModule {
-  /**
-   * Static configuration. Use this when all BPM options are known at module
-   * wiring time (no async secret loading needed).
-   */
-  static forRoot(options: BPMRootModuleOptions): DynamicModule {
-    const featureModules = createBPMFeatureModules(options);
-
-    return {
-      exports: [...featureModules],
-      imports: [...(options.imports ?? []), ...featureModules],
-      module: BPMRootModule,
-    };
-  }
-
-  /**
-   * Async configuration. Use this when BPM options must be resolved at
-   * runtime — typically when SMTP, webhook, or signature secrets are
-   * loaded from Vault / KMS / a host `ConfigService`.
-   *
-   * Routing-time decisions such as `attachmentRoutePrefix`,
-   * `memberResolverProvider`, `attachmentStorageProvider`, and
-   * `workflowServiceTaskDispatcherProvider` are read from the top-level
-   * options object (not from the `useFactory` return value), because
-   * Nest reads controller path metadata and provider tokens synchronously
-   * during application bootstrap.
-   */
-  static forRootAsync(options: BPMRootModuleAsyncOptions): DynamicModule {
-    const authOptions: BPMAuthModuleAsyncOptions = {
-      imports: options.imports,
-      inject: options.inject,
-      useFactory: async (
-        ...args: readonly unknown[]
-      ): Promise<BPMAuthModuleOptions> => {
-        const rootOptions = await options.useFactory(...args);
-
-        return createBPMAuthModuleOptions(rootOptions);
-      },
-    };
-
-    return {
-      exports: [
-        NotificationOptionsModule,
-        BPMAuthModule,
-        IdentityModule,
-        OrganizationModule,
-        AttachmentModule,
-        FormModule,
-        TemplateModule,
-        DelegationModule,
-        NotificationModule,
-        SignatureModule,
-        WorkflowEngineModule,
-      ],
-      imports: [
-        NotificationOptionsModule.forRootAsync({
-          imports: options.imports,
-          inject: options.inject,
-          useFactory: options.useFactory,
-        }),
-        BPMAuthModule.forRootAsync(authOptions),
-        IdentityModule.forRootAsync({
-          imports: options.imports,
-          inject: options.inject,
-          memberResolverProvider: options.memberResolverProvider,
-          useFactory: options.useFactory,
-        }),
-        OrganizationModule,
-        AttachmentModule.forRootAsync({
-          attachmentRoutePrefix: options.attachmentRoutePrefix,
-          imports: options.imports,
-          inject: options.inject,
-          storageProvider: options.attachmentStorageProvider,
-          useFactory: options.useFactory,
-        }),
-        FormModule,
-        TemplateModule,
-        DelegationModule,
-        NotificationModule,
-        SignatureModule.forRootAsync({
-          imports: options.imports,
-          inject: options.inject,
-          useFactory: options.useFactory,
-        }),
-        WorkflowEngineModule.forRoot({
-          imports: options.imports,
-          serviceTaskDispatcherProvider:
-            options.workflowServiceTaskDispatcherProvider,
-        }),
-      ],
-      module: BPMRootModule,
-    };
-  }
-}
-
-function createBPMFeatureModules(
-  options: BPMRootModuleOptions,
-): BPMModuleImport[] {
-  return [
-    NotificationOptionsModule.forRoot(options),
-    BPMAuthModule.forRoot(createBPMAuthModuleOptions(options)),
-    IdentityModule.forRoot({
-      ...options,
-      imports: options.imports,
-      memberResolverProvider: options.memberResolverProvider,
-    }),
-    OrganizationModule,
-    AttachmentModule.forRoot({
-      ...options,
-      imports: options.imports,
-      storageProvider: options.attachmentStorageProvider,
-    }),
-    FormModule,
-    TemplateModule,
-    DelegationModule,
-    NotificationModule,
-    SignatureModule.forRoot(options),
-    WorkflowEngineModule.forRoot({
-      imports: options.imports,
-      serviceTaskDispatcherProvider:
-        options.workflowServiceTaskDispatcherProvider,
-    }),
-  ];
-}
-
-function createBPMAuthModuleOptions(
-  options: BPMRootModuleOptions | BPMRootModuleAsyncFactoryOptions,
-): BPMAuthModuleOptions {
-  return {
-    contextFactory: options.authContextFactory,
-  };
-}

package/src/lib/bpm-auth/bpm-auth-context.extractor.ts

@@ -1,106 +0,0 @@
-import { ExecutionContext } from '@nestjs/common';
-import { GqlExecutionContext } from '@nestjs/graphql';
-import { BPMAuthContext } from './bpm-auth-context';
-
-interface BPMContextCarrier {
-  bpmAuthContext?: unknown;
-}
-
-interface BPMRequestCarrier extends BPMContextCarrier {
-  readonly req?: BPMContextCarrier;
-}
-
-export function attachBPMAuthContext(
-  context: ExecutionContext | undefined,
-  authContext: BPMAuthContext,
-): void {
-  if (!context) {
-    return;
-  }
-
-  const graphqlContext = GqlExecutionContext.create(context).getContext<
-    BPMRequestCarrier | undefined
-  >();
-
-  if (graphqlContext) {
-    graphqlContext.bpmAuthContext = authContext;
-
-    if (graphqlContext.req) {
-      graphqlContext.req.bpmAuthContext = authContext;
-    }
-
-    return;
-  }
-
-  const httpRequest = context
-    .switchToHttp()
-    .getRequest<BPMContextCarrier | undefined>();
-
-  if (httpRequest) {
-    httpRequest.bpmAuthContext = authContext;
-  }
-}
-
-export function extractBPMAuthContext(
-  context?: ExecutionContext,
-): BPMAuthContext | null {
-  if (!context) {
-    return null;
-  }
-
-  const graphqlContext = GqlExecutionContext.create(context).getContext<
-    BPMRequestCarrier | undefined
-  >();
-  const graphqlAuthContext = readBPMAuthContext(graphqlContext?.bpmAuthContext);
-
-  if (graphqlAuthContext) {
-    return graphqlAuthContext;
-  }
-
-  const requestAuthContext = readBPMAuthContext(
-    graphqlContext?.req?.bpmAuthContext,
-  );
-
-  if (requestAuthContext) {
-    return requestAuthContext;
-  }
-
-  const httpRequest = context
-    .switchToHttp()
-    .getRequest<BPMContextCarrier | undefined>();
-
-  return readBPMAuthContext(httpRequest?.bpmAuthContext);
-}
-
-function readBPMAuthContext(value: unknown): BPMAuthContext | null {
-  if (!isRecord(value)) {
-    return null;
-  }
-
-  const memberId = value.memberId;
-
-  if (typeof memberId !== 'string') {
-    return null;
-  }
-
-  return {
-    memberId,
-    metadata: readRecord(value.metadata),
-    permissions: readStringArray(value.permissions),
-    roles: readStringArray(value.roles),
-  };
-}
-
-function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
-  return typeof value === 'object' && value !== null;
-}
-
-function readRecord(value: unknown): Readonly<Record<string, unknown>> {
-  return isRecord(value) ? value : {};
-}
-
-function readStringArray(value: unknown): readonly string[] {
-  return Array.isArray(value)
-    ? value.filter((item): item is string => typeof item === 'string')
-    : [];
-}

package/src/lib/bpm-auth/bpm-auth-context.ts

@@ -1,40 +0,0 @@
-import { ExecutionContext, UnauthorizedException } from '@nestjs/common';
-
-/**
- * The minimum authentication context BPM needs to make authorization
- * decisions. Hosts construct this from their own session / JWT / RBAC
- * source and surface it through `BPMRootModuleOptions.authContextFactory`.
- *
- * `roles` and `permissions` are matched against the string sets defined in
- * `BPMAdminGuard` and `BPMDesignerGuard` — see the role / permission table
- * in `libs/bpm-core/README.md` for the exact strings.
- */
-export interface BPMAuthContext {
-  readonly memberId: string;
-  readonly metadata: Readonly<Record<string, unknown>>;
-  readonly permissions: readonly string[];
-  readonly roles: readonly string[];
-}
-
-export interface BPMAuthContextAccessor {
-  assertAuthenticated(context?: ExecutionContext): Promise<BPMAuthContext>;
-  getCurrentContext(context?: ExecutionContext): Promise<BPMAuthContext | null>;
-  getCurrentMemberId(context?: ExecutionContext): Promise<string>;
-}
-
-export const BPM_AUTH_CONTEXT_ACCESSOR = Symbol('BPM_AUTH_CONTEXT_ACCESSOR');
-
-export const BPM_AUTH_MODULE_OPTIONS = Symbol('BPM_AUTH_MODULE_OPTIONS');
-
-export async function readAuthenticatedBPMContext(
-  accessor: BPMAuthContextAccessor,
-  context?: ExecutionContext,
-): Promise<BPMAuthContext> {
-  const authContext = await accessor.assertAuthenticated(context);
-
-  if (!authContext.memberId.trim()) {
-    throw new UnauthorizedException('BPM member id is required');
-  }
-
-  return authContext;
-}

package/src/lib/bpm-auth/bpm-auth.authorization.ts

@@ -1,80 +0,0 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  ForbiddenException,
-  Injectable,
-  UseGuards,
-} from '@nestjs/common';
-import { BPMAuthContext } from './bpm-auth-context';
-import { extractBPMAuthContext } from './bpm-auth-context.extractor';
-import { BPMAuthenticatedGuard } from './bpm-auth.guard';
-
-const ADMIN_PERMISSIONS = new Set([
-  'bpm:*',
-  'bpm:admin',
-  'bpm.admin',
-  'bpm:admin:*',
-]);
-const DESIGNER_PERMISSIONS = new Set([
-  'bpm:*',
-  'bpm:admin',
-  'bpm.admin',
-  'bpm:admin:*',
-  'bpm:design',
-  'bpm.design',
-  'bpm.form.design',
-  'bpm.template.design',
-  'bpm:form:design',
-  'bpm:template:design',
-]);
-
-@Injectable()
-export class BPMAdminGuard implements CanActivate {
-  canActivate(context: ExecutionContext): boolean {
-    const authContext = extractBPMAuthContext(context);
-
-    if (authContext && isBPMAdmin(authContext)) {
-      return true;
-    }
-
-    throw new ForbiddenException('BPM admin permission is required');
-  }
-}
-
-@Injectable()
-export class BPMDesignerGuard implements CanActivate {
-  canActivate(context: ExecutionContext): boolean {
-    const authContext = extractBPMAuthContext(context);
-
-    if (authContext && isBPMDesigner(authContext)) {
-      return true;
-    }
-
-    throw new ForbiddenException('BPM designer permission is required');
-  }
-}
-
-export const BPMAdminOnly = (): ClassDecorator & MethodDecorator =>
-  UseGuards(BPMAuthenticatedGuard, BPMAdminGuard);
-
-export const BPMDesignerOnly = (): ClassDecorator & MethodDecorator =>
-  UseGuards(BPMAuthenticatedGuard, BPMDesignerGuard);
-
-export function isBPMAdmin(authContext: BPMAuthContext): boolean {
-  return (
-    authContext.roles.includes('BPM_ADMIN') ||
-    authContext.permissions.some((permission) =>
-      ADMIN_PERMISSIONS.has(permission),
-    )
-  );
-}
-
-export function isBPMDesigner(authContext: BPMAuthContext): boolean {
-  return (
-    isBPMAdmin(authContext) ||
-    authContext.roles.includes('BPM_DESIGNER') ||
-    authContext.permissions.some((permission) =>
-      DESIGNER_PERMISSIONS.has(permission),
-    )
-  );
-}

package/src/lib/bpm-auth/bpm-auth.decorators.ts

@@ -1,19 +0,0 @@
-import {
-  createParamDecorator,
-  ExecutionContext,
-  UseGuards,
-} from '@nestjs/common';
-import { BPMAuthenticatedGuard } from './bpm-auth.guard';
-import { extractBPMAuthContext } from './bpm-auth-context.extractor';
-
-export const BPMAuthenticated = (): ClassDecorator & MethodDecorator =>
-  UseGuards(BPMAuthenticatedGuard);
-
-export const BPMCurrentAuthContext = createParamDecorator(
-  (_data: unknown, context: ExecutionContext) => extractBPMAuthContext(context),
-);
-
-export const BPMCurrentMemberId = createParamDecorator(
-  (_data: unknown, context: ExecutionContext) =>
-    extractBPMAuthContext(context)?.memberId ?? null,
-);

package/src/lib/bpm-auth/bpm-auth.guard.ts

@@ -1,31 +0,0 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  Inject,
-  Injectable,
-} from '@nestjs/common';
-import {
-  BPM_AUTH_CONTEXT_ACCESSOR,
-  BPMAuthContextAccessor,
-  readAuthenticatedBPMContext,
-} from './bpm-auth-context';
-import { attachBPMAuthContext } from './bpm-auth-context.extractor';
-
-@Injectable()
-export class BPMAuthenticatedGuard implements CanActivate {
-  constructor(
-    @Inject(BPM_AUTH_CONTEXT_ACCESSOR)
-    private readonly authContextAccessor: BPMAuthContextAccessor,
-  ) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const authContext = await readAuthenticatedBPMContext(
-      this.authContextAccessor,
-      context,
-    );
-
-    attachBPMAuthContext(context, authContext);
-
-    return true;
-  }
-}

package/src/lib/bpm-auth/bpm-auth.module.spec.ts

@@ -1,106 +0,0 @@
-import { Injectable, Module, Type } from '@nestjs/common';
-import type { ExecutionContext } from '@nestjs/common';
-import { Test } from '@nestjs/testing';
-import { BPM_AUTH_CONTEXT_ACCESSOR } from './bpm-auth-context';
-import { BPMAuthenticatedGuard } from './bpm-auth.guard';
-import { BPMAuthModule } from './bpm-auth.module';
-import { extractBPMAuthContext } from './bpm-auth-context.extractor';
-
-@Injectable()
-class FeatureConsumer {
-  constructor(readonly guard: BPMAuthenticatedGuard) {}
-}
-
-@Module({
-  providers: [FeatureConsumer],
-})
-class FeatureModule {}
-
-describe('BPMAuthModule', () => {
-  it('makes BPMAuthenticatedGuard injectable from feature module contexts', async (): Promise<void> => {
-    const moduleRef = await Test.createTestingModule({
-      imports: [BPMAuthModule.forRoot(), FeatureModule],
-    }).compile();
-
-    try {
-      const consumer = moduleRef.get(FeatureConsumer);
-
-      expect(consumer.guard).toBeInstanceOf(BPMAuthenticatedGuard);
-    } finally {
-      await moduleRef.close();
-    }
-  });
-
-  it('makes factory auth context visible to current member decorators after guard activation', async (): Promise<void> => {
-    const moduleRef = await Test.createTestingModule({
-      imports: [
-        BPMAuthModule.forRoot({
-          contextFactory: () => ({
-            memberId: 'member-from-factory',
-            metadata: {},
-            permissions: [],
-            roles: [],
-          }),
-        }),
-      ],
-    }).compile();
-
-    try {
-      const guard = moduleRef.get(BPMAuthenticatedGuard);
-      const graphqlContext: Record<string, unknown> = {};
-      const executionContext = createGraphQLExecutionContext(graphqlContext);
-
-      await expect(guard.canActivate(executionContext)).resolves.toBe(true);
-      expect(extractBPMAuthContext(executionContext)?.memberId).toBe(
-        'member-from-factory',
-      );
-      expect(graphqlContext.bpmAuthContext).toMatchObject({
-        memberId: 'member-from-factory',
-      });
-    } finally {
-      await moduleRef.close();
-    }
-  });
-
-  it('keeps the auth context accessor injectable for direct host integrations', async (): Promise<void> => {
-    const moduleRef = await Test.createTestingModule({
-      imports: [BPMAuthModule.forRoot()],
-    }).compile();
-
-    try {
-      expect(moduleRef.get(BPM_AUTH_CONTEXT_ACCESSOR)).toBeDefined();
-    } finally {
-      await moduleRef.close();
-    }
-  });
-});
-
-function createGraphQLExecutionContext(
-  graphqlContext: Record<string, unknown>,
-): ExecutionContext {
-  const args = [undefined, {}, graphqlContext, undefined];
-  const readUndefined = <T = unknown>(): T => undefined as T;
-
-  return {
-    getArgByIndex: <T = unknown>(index: number): T => args[index] as T,
-    getArgs: <T extends readonly unknown[] = readonly unknown[]>(): T =>
-      args as unknown as T,
-    getClass: <T = unknown>(): Type<T> => FeatureConsumer as Type<T>,
-    getHandler: () => FeatureConsumer.prototype.constructor,
-    getType: () => 'graphql' as never,
-    switchToHttp: () => ({
-      getNext: readUndefined,
-      getRequest: readUndefined,
-      getResponse: readUndefined,
-    }),
-    switchToRpc: () => ({
-      getContext: readUndefined,
-      getData: readUndefined,
-    }),
-    switchToWs: () => ({
-      getClient: readUndefined,
-      getData: readUndefined,
-      getPattern: () => '',
-    }),
-  };
-}