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

package/src/lib/notification/notification.entity.ts

@@ -0,0 +1,129 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import {
+  NotificationChannelEnum,
+  NotificationResolutionEnum,
+  NotificationStatusEnum,
+  NotificationTypeEnum,
+} from './notification.enums';
+
+const ACTIONABLE_NOTIFICATION_TYPES: ReadonlySet<NotificationTypeEnum> =
+  new Set([
+    NotificationTypeEnum.TASK_ASSIGNED,
+    NotificationTypeEnum.TASK_TRANSFERRED,
+  ]);
+
+@Entity('notifications')
+@Index('IDX_notifications_pending_delivery', [
+  'status',
+  'nextRetryAt',
+  'createdAt',
+])
+@ObjectType('Notification')
+export class NotificationEntity {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(() => ID)
+  id!: string;
+
+  @Column('text', { name: 'recipient_member_id' })
+  @Field()
+  recipientMemberId!: string;
+
+  @Column('text')
+  @Field(() => NotificationChannelEnum)
+  channel!: NotificationChannelEnum;
+
+  @Column('text')
+  @Field(() => NotificationTypeEnum)
+  type!: NotificationTypeEnum;
+
+  @Column('uuid', { name: 'instance_id', nullable: true })
+  @Field(() => ID, { nullable: true })
+  instanceId!: string | null;
+
+  @Column('uuid', { name: 'task_id', nullable: true })
+  @Field(() => ID, { nullable: true })
+  taskId!: string | null;
+
+  @Column('text')
+  @Field()
+  title!: string;
+
+  @Column('text')
+  @Field()
+  body!: string;
+
+  @Column('jsonb')
+  payload!: Readonly<Record<string, unknown>>;
+
+  @Column('text')
+  @Field(() => NotificationStatusEnum)
+  status!: NotificationStatusEnum;
+
+  @Column('text', { name: 'resolution', nullable: true })
+  @Field(() => NotificationResolutionEnum, { nullable: true })
+  resolution!: NotificationResolutionEnum | null;
+
+  @Column('timestamptz', { name: 'resolved_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  resolvedAt!: Date | null;
+
+  @Column('timestamptz', { name: 'sent_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  sentAt!: Date | null;
+
+  @Column('timestamptz', { name: 'read_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  readAt!: Date | null;
+
+  @Column('integer', { name: 'attempt_count', default: 0 })
+  @Field(() => Number)
+  attemptCount!: number;
+
+  @Column('timestamptz', { name: 'last_attempt_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  lastAttemptAt!: Date | null;
+
+  @Column('timestamptz', { name: 'next_retry_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  nextRetryAt!: Date | null;
+
+  @Column('text', { name: 'delivery_error', nullable: true })
+  @Field(() => String, { nullable: true })
+  deliveryError!: string | null;
+
+  @Column('timestamptz', { name: 'delivered_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  deliveredAt!: Date | null;
+
+  @Column('text', { name: 'delivery_target', nullable: true })
+  @Field(() => String, { nullable: true })
+  deliveryTarget!: string | null;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  @Field()
+  createdAt!: Date;
+
+  @Field(() => String)
+  get payloadJson(): string {
+    return JSON.stringify(this.payload ?? {});
+  }
+
+  /**
+   * Whether the recipient can still act on this notification (i.e. it is an
+   * unresolved task-assignment). Drives the inline 同意/拒絕 actions on the
+   * client so they are never offered for an already-decided task.
+   */
+  @Field(() => Boolean)
+  get actionable(): boolean {
+    return (
+      ACTIONABLE_NOTIFICATION_TYPES.has(this.type) && this.resolution == null
+    );
+  }
+}

package/src/lib/notification/notification.enums.ts

@@ -0,0 +1,64 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+export enum NotificationChannelEnum {
+  EMAIL = 'EMAIL',
+  IN_APP = 'IN_APP',
+  WEBHOOK = 'WEBHOOK',
+}
+
+export enum NotificationDigestModeEnum {
+  DAILY = 'DAILY',
+  INSTANT = 'INSTANT',
+}
+
+export enum NotificationStatusEnum {
+  DELIVERY_IN_PROGRESS = 'DELIVERY_IN_PROGRESS',
+  FAILED = 'FAILED',
+  PENDING = 'PENDING',
+  READ = 'READ',
+  SENT = 'SENT',
+}
+
+/**
+ * Action-lifecycle of an actionable notification (TASK_ASSIGNED /
+ * TASK_TRANSFERRED), orthogonal to the delivery `status`. `null` resolution
+ * means the action is still OPEN (awaiting the recipient's decision); any
+ * non-null value means the notification has been resolved and its inline
+ * 同意/拒絕 actions must no longer be offered.
+ */
+export enum NotificationResolutionEnum {
+  APPROVED = 'APPROVED',
+  REJECTED = 'REJECTED',
+  RETURNED = 'RETURNED',
+  TRANSFERRED = 'TRANSFERRED',
+  SUPERSEDED = 'SUPERSEDED',
+}
+
+export enum NotificationTypeEnum {
+  INSTANCE_COMPLETED = 'INSTANCE_COMPLETED',
+  SLA_OVERDUE = 'SLA_OVERDUE',
+  SLA_WARNING = 'SLA_WARNING',
+  TASK_ASSIGNED = 'TASK_ASSIGNED',
+  TASK_TRANSFERRED = 'TASK_TRANSFERRED',
+  WORKFLOW_NOTIFICATION = 'WORKFLOW_NOTIFICATION',
+}
+
+registerEnumType(NotificationChannelEnum, {
+  name: 'NotificationChannel',
+});
+
+registerEnumType(NotificationDigestModeEnum, {
+  name: 'NotificationDigestMode',
+});
+
+registerEnumType(NotificationStatusEnum, {
+  name: 'NotificationStatus',
+});
+
+registerEnumType(NotificationResolutionEnum, {
+  name: 'NotificationResolution',
+});
+
+registerEnumType(NotificationTypeEnum, {
+  name: 'NotificationType',
+});

package/src/lib/notification/notification.module.ts

@@ -0,0 +1,37 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ActivityLogEntity } from '../workflow-engine/activity-log.entity';
+import { ApprovalInstanceEntity } from '../workflow-engine/approval-instance.entity';
+import { TaskCandidateEntity } from '../workflow-engine/task-candidate.entity';
+import { TaskEntity } from '../workflow-engine/task.entity';
+import { NotificationPreferenceEntity } from './notification-preference.entity';
+import { NotificationDeliverySchedulerService } from './notification-delivery-scheduler.service';
+import { NotificationDeliveryService } from './notification-delivery.service';
+import { NotificationEntity } from './notification.entity';
+import { NotificationMutations } from './notification.mutations';
+import { NotificationQueries } from './notification.queries';
+import { NotificationSlaSchedulerService } from './notification-sla-scheduler.service';
+import { NotificationService } from './notification.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([
+      ActivityLogEntity,
+      ApprovalInstanceEntity,
+      NotificationEntity,
+      NotificationPreferenceEntity,
+      TaskCandidateEntity,
+      TaskEntity,
+    ]),
+  ],
+  providers: [
+    NotificationMutations,
+    NotificationQueries,
+    NotificationDeliverySchedulerService,
+    NotificationDeliveryService,
+    NotificationService,
+    NotificationSlaSchedulerService,
+  ],
+  exports: [NotificationDeliveryService, NotificationService],
+})
+export class NotificationModule {}

package/src/lib/notification/notification.mutations.ts

@@ -0,0 +1,47 @@
+import { Args, Int, Mutation, Resolver } from '@nestjs/graphql';
+import { BPMAuthenticated, BPMCurrentMemberId } from '../bpm-auth';
+import { UpdateNotificationPreferenceInput } from './dto/notification-preference.input';
+import { NotificationPreferenceEntity } from './notification-preference.entity';
+import { NotificationEntity } from './notification.entity';
+import { NotificationService } from './notification.service';
+
+@Resolver()
+@BPMAuthenticated()
+export class NotificationMutations {
+  constructor(private readonly notificationService: NotificationService) {}
+
+  @Mutation(() => NotificationEntity)
+  async markNotificationRead(
+    @Args('id', { type: () => String }) id: string,
+    @Args('readerMemberId', { nullable: true, type: () => String })
+    readerMemberId?: string | null,
+    @BPMCurrentMemberId() currentMemberId?: string,
+  ): Promise<NotificationEntity> {
+    return this.notificationService.markNotificationRead({
+      id,
+      readerMemberId: currentMemberId ?? readerMemberId ?? null,
+    });
+  }
+
+  @Mutation(() => Int)
+  async markAllNotificationsRead(
+    @BPMCurrentMemberId() currentMemberId: string,
+    @Args('recipientMemberId', { nullable: true, type: () => String })
+    recipientMemberId?: string | null,
+  ): Promise<number> {
+    return this.notificationService.markAllNotificationsRead({
+      recipientMemberId: currentMemberId ?? recipientMemberId ?? '',
+    });
+  }
+
+  @Mutation(() => NotificationPreferenceEntity)
+  async updateNotificationPreference(
+    @Args('input') input: UpdateNotificationPreferenceInput,
+    @BPMCurrentMemberId() currentMemberId: string,
+  ): Promise<NotificationPreferenceEntity> {
+    return this.notificationService.updatePreference({
+      ...input,
+      memberId: currentMemberId,
+    });
+  }
+}

package/src/lib/notification/notification.queries.ts

@@ -0,0 +1,64 @@
+import { Args, Int, Query, Resolver } from '@nestjs/graphql';
+import { BPMAuthenticated, BPMCurrentMemberId } from '../bpm-auth';
+import { NotificationPreferenceEntity } from './notification-preference.entity';
+import { NotificationEntity } from './notification.entity';
+import { NotificationService } from './notification.service';
+
+@Resolver()
+@BPMAuthenticated()
+export class NotificationQueries {
+  constructor(private readonly notificationService: NotificationService) {}
+
+  @Query(() => [NotificationEntity])
+  async notifications(
+    @Args('recipientMemberId', { type: () => String })
+    recipientMemberId: string,
+    @Args('includeRead', { nullable: true, type: () => Boolean })
+    includeRead?: boolean | null,
+    @Args('page', { nullable: true, type: () => Int })
+    page?: number | null,
+    @Args('pageSize', { nullable: true, type: () => Int })
+    pageSize?: number | null,
+    @BPMCurrentMemberId() currentMemberId?: string,
+  ): Promise<readonly NotificationEntity[]> {
+    return this.notificationService.listNotifications({
+      includeRead: includeRead ?? false,
+      page: page ?? 1,
+      pageSize: pageSize ?? 10,
+      recipientMemberId: currentMemberId ?? recipientMemberId,
+    });
+  }
+
+  @Query(() => Int)
+  async notificationCount(
+    @Args('recipientMemberId', { type: () => String })
+    recipientMemberId: string,
+    @Args('includeRead', { nullable: true, type: () => Boolean })
+    includeRead?: boolean | null,
+    @BPMCurrentMemberId() currentMemberId?: string,
+  ): Promise<number> {
+    return this.notificationService.countNotifications({
+      includeRead: includeRead ?? false,
+      recipientMemberId: currentMemberId ?? recipientMemberId,
+    });
+  }
+
+  @Query(() => Int)
+  async unreadNotificationCount(
+    @Args('recipientMemberId', { type: () => String })
+    recipientMemberId: string,
+    @BPMCurrentMemberId() currentMemberId?: string,
+  ): Promise<number> {
+    return this.notificationService.countUnreadNotifications(
+      currentMemberId ?? recipientMemberId,
+    );
+  }
+
+  @Query(() => NotificationPreferenceEntity)
+  async notificationPreference(
+    @Args('memberId', { type: () => String }) memberId: string,
+    @BPMCurrentMemberId() currentMemberId?: string,
+  ): Promise<NotificationPreferenceEntity> {
+    return this.notificationService.getPreference(currentMemberId ?? memberId);
+  }
+}