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

package/src/lib/migrations/{0000000015000-backfill-stale-notification-resolution.js → 0000000015000-backfill-stale-notification-resolution.ts}

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackfillStaleNotificationResolution0000000015000 = void 0;
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
 /**
  * Backfill the action-lifecycle of notifications created before the write-side
  * resolution wiring existed. Any TASK_ASSIGNED / TASK_TRANSFERRED notification
@@ -10,12 +9,13 @@ exports.BackfillStaleNotificationResolution0000000015000 = void 0;
  *
  * Idempotent: the `resolution IS NULL` guard means re-running it is a no-op.
  */
-class BackfillStaleNotificationResolution0000000015000 {
-    constructor() {
-        this.name = 'BackfillStaleNotificationResolution0000000015000';
-    }
-    async up(queryRunner) {
-        await queryRunner.query(`
+export class BackfillStaleNotificationResolution0000000015000
+  implements MigrationInterface
+{
+  name = 'BackfillStaleNotificationResolution0000000015000';
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
       UPDATE "notifications" AS n
       SET "resolution" = 'SUPERSEDED',
           "resolved_at" = now(),
@@ -27,11 +27,10 @@ class BackfillStaleNotificationResolution0000000015000 {
         AND n."resolution" IS NULL
         AND t."status" IN ('COMPLETED', 'CANCELLED', 'TRANSFERRED')
     `);
-    }
-    async down() {
-        // Data backfill — no safe automatic revert (cannot distinguish rows that
-        // were backfilled from rows later superseded through normal operation).
-    }
+  }
+
+  async down(): Promise<void> {
+    // Data backfill — no safe automatic revert (cannot distinguish rows that
+    // were backfilled from rows later superseded through normal operation).
+  }
 }
-exports.BackfillStaleNotificationResolution0000000015000 = BackfillStaleNotificationResolution0000000015000;
-//# sourceMappingURL=0000000015000-backfill-stale-notification-resolution.js.map

package/src/lib/migrations/{0000000016000-archive-parallel-form-drafts.js → 0000000016000-archive-parallel-form-drafts.ts}

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArchiveParallelFormDrafts0000000016000 = void 0;
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
 /**
  * Form definitions no longer keep a DRAFT version in parallel with a
  * published one: after the first publish every save publishes a brand-new
@@ -10,12 +9,13 @@ exports.ArchiveParallelFormDrafts0000000016000 = void 0;
  *
  * Idempotent: the `status = 'DRAFT'` guard means re-running it is a no-op.
  */
-class ArchiveParallelFormDrafts0000000016000 {
-    constructor() {
-        this.name = 'ArchiveParallelFormDrafts0000000016000';
-    }
-    async up(queryRunner) {
-        await queryRunner.query(`
+export class ArchiveParallelFormDrafts0000000016000
+  implements MigrationInterface
+{
+  name = 'ArchiveParallelFormDrafts0000000016000';
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
       UPDATE "form_definition_versions" AS v
       SET "status" = 'ARCHIVED',
           "archived_at" = COALESCE(v."archived_at", now())
@@ -24,11 +24,10 @@ class ArchiveParallelFormDrafts0000000016000 {
         AND v."status" = 'DRAFT'
         AND d."current_version_id" IS NOT NULL
     `);
-    }
-    async down() {
-        // Data cleanup — no safe automatic revert (cannot distinguish rows
-        // archived here from versions archived through normal publishing).
-    }
+  }
+
+  async down(): Promise<void> {
+    // Data cleanup — no safe automatic revert (cannot distinguish rows
+    // archived here from versions archived through normal publishing).
+  }
 }
-exports.ArchiveParallelFormDrafts0000000016000 = ArchiveParallelFormDrafts0000000016000;
-//# sourceMappingURL=0000000016000-archive-parallel-form-drafts.js.map

package/src/lib/migrations/{0000000017000-adhoc-directives.js → 0000000017000-adhoc-directives.ts}

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdhocDirectives0000000017000 = void 0;
-class AdhocDirectives0000000017000 {
-    constructor() {
-        this.name = 'AdhocDirectives0000000017000';
-    }
-    async up(queryRunner) {
-        await queryRunner.query(`
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AdhocDirectives0000000017000 implements MigrationInterface {
+  name = 'AdhocDirectives0000000017000';
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
       CREATE TABLE IF NOT EXISTS "task_adhoc_directives" (
         "id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
         "instance_id" uuid NOT NULL,
@@ -24,30 +22,31 @@ class AdhocDirectives0000000017000 {
         "created_at" timestamptz NOT NULL DEFAULT now()
       )
     `);
-        await queryRunner.query(`
+    await queryRunner.query(`
       CREATE INDEX IF NOT EXISTS "IDX_adhoc_directives_pending"
       ON "task_adhoc_directives" ("instance_id", "type")
       WHERE "status" = 'PENDING'
     `);
-        await queryRunner.query(`
+    await queryRunner.query(`
       ALTER TABLE "tasks"
       ADD COLUMN IF NOT EXISTS "is_adhoc" boolean NOT NULL DEFAULT false,
       ADD COLUMN IF NOT EXISTS "adhoc_type" text NULL,
       ADD COLUMN IF NOT EXISTS "adhoc_origin_task_id" uuid NULL,
       ADD COLUMN IF NOT EXISTS "adhoc_directive_id" uuid NULL
     `);
-    }
-    async down(queryRunner) {
-        await queryRunner.query(`
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
       ALTER TABLE "tasks"
       DROP COLUMN IF EXISTS "adhoc_directive_id",
       DROP COLUMN IF EXISTS "adhoc_origin_task_id",
       DROP COLUMN IF EXISTS "adhoc_type",
       DROP COLUMN IF EXISTS "is_adhoc"
     `);
-        await queryRunner.query('DROP INDEX IF EXISTS "IDX_adhoc_directives_pending"');
-        await queryRunner.query('DROP TABLE IF EXISTS "task_adhoc_directives"');
-    }
+    await queryRunner.query(
+      'DROP INDEX IF EXISTS "IDX_adhoc_directives_pending"',
+    );
+    await queryRunner.query('DROP TABLE IF EXISTS "task_adhoc_directives"');
+  }
 }
-exports.AdhocDirectives0000000017000 = AdhocDirectives0000000017000;
-//# sourceMappingURL=0000000017000-adhoc-directives.js.map

package/src/lib/migrations/index.ts

@@ -0,0 +1,59 @@
+import { MigrationInterface } from 'typeorm';
+import { EnablePostgresExtensions0000000000001 } from './0000000000001-enable-postgres-extensions';
+import { IdentityOrganizationFoundation0000000001000 } from './0000000001000-identity-organization-foundation';
+import { FormBuilderFoundation0000000002000 } from './0000000002000-form-builder-foundation';
+import { ApprovalTemplateFoundation0000000003000 } from './0000000003000-approval-template-foundation';
+import { WorkflowEngineFoundation0000000004000 } from './0000000004000-workflow-engine-foundation';
+import { DelegationRules0000000005000 } from './0000000005000-delegation-rules';
+import { NotificationsSla0000000006000 } from './0000000006000-notifications-sla';
+import { SignaturesAttachments0000000007000 } from './0000000007000-signatures-attachments';
+import { ApprovalTemplateCategories0000000008000 } from './0000000008000-approval-template-categories';
+import { TaskCandidates0000000009000 } from './0000000009000-task-candidates';
+import { NotificationDeliveryState0000000010000 } from './0000000010000-notification-delivery-state';
+import { RemoveAttachmentEncryptionKey0000000011000 } from './0000000011000-remove-attachment-encryption-key';
+import { NotificationSlaIdempotency0000000012000 } from './0000000012000-notification-sla-idempotency';
+import { WorkflowQueryIndexes0000000013000 } from './0000000013000-workflow-query-indexes';
+import { NotificationResolution0000000014000 } from './0000000014000-notification-resolution';
+import { BackfillStaleNotificationResolution0000000015000 } from './0000000015000-backfill-stale-notification-resolution';
+import { ArchiveParallelFormDrafts0000000016000 } from './0000000016000-archive-parallel-form-drafts';
+import { AdhocDirectives0000000017000 } from './0000000017000-adhoc-directives';
+
+export const BPM_CORE_MIGRATIONS: readonly (new () => MigrationInterface)[] = [
+  EnablePostgresExtensions0000000000001,
+  IdentityOrganizationFoundation0000000001000,
+  FormBuilderFoundation0000000002000,
+  ApprovalTemplateFoundation0000000003000,
+  WorkflowEngineFoundation0000000004000,
+  DelegationRules0000000005000,
+  NotificationsSla0000000006000,
+  SignaturesAttachments0000000007000,
+  ApprovalTemplateCategories0000000008000,
+  TaskCandidates0000000009000,
+  NotificationDeliveryState0000000010000,
+  RemoveAttachmentEncryptionKey0000000011000,
+  NotificationSlaIdempotency0000000012000,
+  WorkflowQueryIndexes0000000013000,
+  NotificationResolution0000000014000,
+  BackfillStaleNotificationResolution0000000015000,
+  ArchiveParallelFormDrafts0000000016000,
+  AdhocDirectives0000000017000,
+];
+
+export * from './0000000000001-enable-postgres-extensions';
+export * from './0000000001000-identity-organization-foundation';
+export * from './0000000002000-form-builder-foundation';
+export * from './0000000003000-approval-template-foundation';
+export * from './0000000004000-workflow-engine-foundation';
+export * from './0000000005000-delegation-rules';
+export * from './0000000006000-notifications-sla';
+export * from './0000000007000-signatures-attachments';
+export * from './0000000008000-approval-template-categories';
+export * from './0000000009000-task-candidates';
+export * from './0000000010000-notification-delivery-state';
+export * from './0000000011000-remove-attachment-encryption-key';
+export * from './0000000012000-notification-sla-idempotency';
+export * from './0000000013000-workflow-query-indexes';
+export * from './0000000014000-notification-resolution';
+export * from './0000000015000-backfill-stale-notification-resolution';
+export * from './0000000016000-archive-parallel-form-drafts';
+export * from './0000000017000-adhoc-directives';

package/src/lib/notification/dto/notification-preference.input.ts

@@ -0,0 +1,46 @@
+import { Field, InputType } from '@nestjs/graphql';
+import {
+  IsBoolean,
+  IsIn,
+  IsOptional,
+  IsString,
+  Matches,
+} from 'class-validator';
+import { NotificationDigestModeEnum } from '../notification.enums';
+
+const TIME_ONLY_PATTERN = /^([01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
+
+@InputType()
+export class UpdateNotificationPreferenceInput {
+  @Field()
+  @IsString()
+  memberId!: string;
+
+  @Field()
+  @IsBoolean()
+  inAppEnabled!: boolean;
+
+  @Field()
+  @IsBoolean()
+  emailEnabled!: boolean;
+
+  @Field(() => NotificationDigestModeEnum)
+  @IsIn(Object.values(NotificationDigestModeEnum))
+  emailDigestMode!: NotificationDigestModeEnum;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  @Matches(TIME_ONLY_PATTERN, {
+    message: 'quietHoursStart must use HH:mm or HH:mm:ss format',
+  })
+  quietHoursStart!: string | null;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  @Matches(TIME_ONLY_PATTERN, {
+    message: 'quietHoursEnd must use HH:mm or HH:mm:ss format',
+  })
+  quietHoursEnd!: string | null;
+}

package/src/lib/notification/notification-delivery-scheduler.service.ts

@@ -0,0 +1,69 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnApplicationBootstrap,
+  OnApplicationShutdown,
+  Optional,
+} from '@nestjs/common';
+import { NotificationDeliveryService } from './notification-delivery.service';
+import {
+  BPM_NOTIFICATION_OPTIONS,
+  BPMResolvedNotificationOptions,
+  DEFAULT_BPM_NOTIFICATION_OPTIONS,
+} from './notification-options';
+
+@Injectable()
+export class NotificationDeliverySchedulerService
+  implements OnApplicationBootstrap, OnApplicationShutdown
+{
+  private readonly logger = new Logger(
+    NotificationDeliverySchedulerService.name,
+  );
+  private timer: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly deliveryService: NotificationDeliveryService,
+    @Optional()
+    @Inject(BPM_NOTIFICATION_OPTIONS)
+    private readonly notificationOptions: BPMResolvedNotificationOptions = DEFAULT_BPM_NOTIFICATION_OPTIONS,
+  ) {}
+
+  onApplicationBootstrap(): void {
+    if (
+      process.env.NODE_ENV === 'test' ||
+      !this.notificationOptions.deliverySchedulerEnabled
+    ) {
+      return;
+    }
+
+    this.timer = setInterval((): void => {
+      void this.scanPendingDeliveries();
+    }, this.notificationOptions.deliveryScanIntervalMs);
+    this.timer.unref();
+  }
+
+  onApplicationShutdown(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private async scanPendingDeliveries(): Promise<void> {
+    try {
+      const deliveredCount =
+        await this.deliveryService.deliverPendingNotifications({
+          options: this.notificationOptions,
+        });
+
+      if (deliveredCount) {
+        this.logger.log(`Delivered ${deliveredCount} pending notifications`);
+      }
+    } catch (error: unknown) {
+      this.logger.error(
+        error instanceof Error ? error.message : 'Delivery scan failed',
+      );
+    }
+  }
+}

package/src/lib/notification/notification-delivery.service.spec.ts

@@ -0,0 +1,315 @@
+import * as nodemailer from 'nodemailer';
+import { ModuleRef } from '@nestjs/core';
+import { Repository } from 'typeorm';
+import { IdentityService } from '../identity/identity.service';
+import { NotificationDeliveryService } from './notification-delivery.service';
+import {
+  BPM_NOTIFICATION_DISPATCHER,
+  BPMNotificationDispatcher,
+} from './notification-dispatcher.token';
+import { NotificationEntity } from './notification.entity';
+import {
+  NotificationChannelEnum,
+  NotificationStatusEnum,
+  NotificationTypeEnum,
+} from './notification.enums';
+import { DEFAULT_BPM_NOTIFICATION_OPTIONS } from './notification-options';
+
+describe('NotificationDeliveryService', () => {
+  afterEach((): void => {
+    jest.restoreAllMocks();
+  });
+
+  it('sends pending email notifications through SMTP and marks them sent', async (): Promise<void> => {
+    const sendMail = jest.fn((): Promise<void> => Promise.resolve());
+    jest.spyOn(nodemailer, 'createTransport').mockReturnValue({
+      sendMail,
+    } as unknown as ReturnType<typeof nodemailer.createTransport>);
+    const notification = createNotification(NotificationChannelEnum.EMAIL);
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef(),
+    );
+
+    await expect(
+      service.deliverNotification(notification, {
+        ...DEFAULT_BPM_NOTIFICATION_OPTIONS,
+        emailEnabled: true,
+        emailFrom: 'BPM <bpm@example.com>',
+        emailSmtpHost: 'smtp.example.com',
+        emailSmtpPassword: 'secret',
+        emailSmtpPort: 587,
+        emailSmtpSecure: false,
+        emailSmtpUsername: 'bpm@example.com',
+      }),
+    ).resolves.toBe(true);
+
+    expect(sendMail).toHaveBeenCalledWith(
+      expect.objectContaining({
+        from: 'BPM <bpm@example.com>',
+        subject: notification.title,
+        text: notification.body,
+        to: 'member-001@example.com',
+      }),
+    );
+    expect(repository.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: NotificationStatusEnum.SENT,
+        deliveryTarget: 'member-001@example.com',
+      }),
+    );
+  });
+
+  it('sends signed webhook notifications', async (): Promise<void> => {
+    const fetchMock = jest.fn(() =>
+      Promise.resolve({
+        ok: true,
+        status: 200,
+      }),
+    );
+    jest
+      .spyOn(globalThis, 'fetch')
+      .mockImplementation(fetchMock as unknown as typeof fetch);
+    const notification = createNotification(NotificationChannelEnum.WEBHOOK);
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef(),
+    );
+
+    await expect(
+      service.deliverNotification(notification, {
+        ...DEFAULT_BPM_NOTIFICATION_OPTIONS,
+        webhookEnabled: true,
+        webhookEndpointUrl: 'https://example.com/bpm-webhook',
+        webhookSigningSecret: 'secret',
+      }),
+    ).resolves.toBe(true);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://example.com/bpm-webhook',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-bpm-signature-sha256': expect.any(String),
+        }),
+        method: 'POST',
+      }),
+    );
+    expect(repository.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: NotificationStatusEnum.SENT,
+        deliveryTarget: 'https://example.com/bpm-webhook',
+      }),
+    );
+  });
+
+  it('dispatches email and webhook notifications through a host dispatcher when provided', async (): Promise<void> => {
+    const dispatch = jest.fn((): Promise<string> => Promise.resolve('queue-1'));
+    const notification = createNotification(NotificationChannelEnum.EMAIL);
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef({
+        dispatch,
+      }),
+    );
+
+    await expect(
+      service.deliverNotification(notification, DEFAULT_BPM_NOTIFICATION_OPTIONS),
+    ).resolves.toBe(true);
+
+    expect(dispatch).toHaveBeenCalledWith(
+      notification,
+      DEFAULT_BPM_NOTIFICATION_OPTIONS,
+    );
+    expect(repository.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        deliveryTarget: 'queue-1',
+        status: NotificationStatusEnum.SENT,
+      }),
+    );
+  });
+
+  it('records delivery failures and schedules a retry', async (): Promise<void> => {
+    const notification = createNotification(NotificationChannelEnum.EMAIL);
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef(),
+    );
+
+    await expect(
+      service.deliverNotification(notification, {
+        ...DEFAULT_BPM_NOTIFICATION_OPTIONS,
+        emailEnabled: false,
+      }),
+    ).resolves.toBe(false);
+
+    expect(repository.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        attemptCount: 1,
+        deliveryError: 'EMAIL_DISABLED',
+        nextRetryAt: expect.any(Date),
+        status: NotificationStatusEnum.PENDING,
+      }),
+    );
+  });
+
+  it('uses configured retry policy and marks notifications failed after max attempts', async (): Promise<void> => {
+    const notification = Object.assign(
+      createNotification(NotificationChannelEnum.EMAIL),
+      { attemptCount: 1 },
+    );
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef(),
+    );
+
+    await expect(
+      service.deliverNotification(notification, {
+        ...DEFAULT_BPM_NOTIFICATION_OPTIONS,
+        deliveryMaxAttempts: 2,
+        deliveryRetryBaseDelayMs: 5_000,
+        emailEnabled: false,
+      }),
+    ).resolves.toBe(false);
+
+    expect(repository.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        attemptCount: 2,
+        nextRetryAt: null,
+        status: NotificationStatusEnum.FAILED,
+      }),
+    );
+  });
+
+  it('uses configured batch size when scanning pending notifications', async (): Promise<void> => {
+    const notification = createNotification(NotificationChannelEnum.IN_APP);
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef(),
+    );
+
+    await service.deliverPendingNotifications({
+      options: {
+        ...DEFAULT_BPM_NOTIFICATION_OPTIONS,
+        deliveryBatchSize: 7,
+      },
+    });
+
+    expect(repository.find).toHaveBeenCalledWith(
+      expect.objectContaining({ take: 7 }),
+    );
+  });
+
+  it('includes stale in-progress notifications in the next delivery scan', async (): Promise<void> => {
+    const notification = createNotification(NotificationChannelEnum.IN_APP);
+    const repository = createNotificationRepository(notification);
+    const service = new NotificationDeliveryService(
+      repository,
+      createModuleRef(),
+    );
+
+    await service.deliverPendingNotifications({
+      now: new Date('2026-05-15T00:10:00.000Z'),
+      options: {
+        ...DEFAULT_BPM_NOTIFICATION_OPTIONS,
+        deliveryRetryBaseDelayMs: 60_000,
+      },
+    });
+
+    expect(repository.find).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.arrayContaining([
+          expect.objectContaining({
+            lastAttemptAt: expect.any(Object),
+            status: NotificationStatusEnum.DELIVERY_IN_PROGRESS,
+          }),
+        ]),
+      }),
+    );
+  });
+});
+
+function createNotification(
+  channel: NotificationChannelEnum,
+): NotificationEntity {
+  return Object.assign(new NotificationEntity(), {
+    attemptCount: 0,
+    body: '請處理待簽任務。',
+    channel,
+    createdAt: new Date('2026-05-15T00:00:00.000Z'),
+    deliveredAt: null,
+    deliveryError: null,
+    deliveryTarget: null,
+    id: 'notification-001',
+    instanceId: 'd6f61a56-8b12-4ab8-9424-a2f7c27874e2',
+    lastAttemptAt: null,
+    nextRetryAt: null,
+    payload: { instanceTitle: '採購申請' },
+    readAt: null,
+    recipientMemberId: 'member-001',
+    sentAt: null,
+    status: NotificationStatusEnum.PENDING,
+    taskId: 'f4fae7b0-eab0-40de-8dfa-7dfbff746980',
+    title: '新的待簽任務',
+    type: NotificationTypeEnum.TASK_ASSIGNED,
+  });
+}
+
+function createNotificationRepository(
+  notification: NotificationEntity,
+): Repository<NotificationEntity> & {
+  readonly find: jest.Mock;
+  readonly save: jest.Mock;
+} {
+  const repository = {
+    find: jest.fn(
+      (): Promise<readonly NotificationEntity[]> =>
+        Promise.resolve([notification]),
+    ),
+    save: jest.fn(
+      (entity: NotificationEntity): Promise<NotificationEntity> =>
+        Promise.resolve(entity),
+    ),
+  };
+
+  return repository as unknown as Repository<NotificationEntity> & {
+    readonly find: jest.Mock;
+    readonly save: jest.Mock;
+  };
+}
+
+function createModuleRef(
+  dispatcher?: BPMNotificationDispatcher,
+): ModuleRef {
+  return {
+    get: (token: unknown): BPMNotificationDispatcher | IdentityService => {
+      if (token === BPM_NOTIFICATION_DISPATCHER && dispatcher) {
+        return dispatcher;
+      }
+
+      if (token !== IdentityService) {
+        throw new Error('Unexpected module token');
+      }
+
+      return {
+        resolveMember: (): Promise<{
+          readonly customFields: Readonly<Record<string, unknown>>;
+          readonly email: string;
+          readonly memberId: string;
+          readonly name: string;
+        }> =>
+          Promise.resolve({
+            customFields: {},
+            email: 'member-001@example.com',
+            memberId: 'member-001',
+            name: '王小明',
+          }),
+      } as unknown as IdentityService;
+    },
+  } as unknown as ModuleRef;
+}