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

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

@@ -0,0 +1,320 @@
+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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,106 @@
+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: () => '',
+    }),
+  };
+}