@rytass/bpm-core-nestjs-module 0.1.1 → 0.1.3

package/src/lib/workflow-engine/approval-instance.entity.ts

@@ -0,0 +1,86 @@
+import { WorkflowDefinition } from '@rytass/bpm-core-shared/workflow';
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { ApprovalInstanceStateEnum } from './workflow-engine.enums';
+
+@Entity('approval_instances')
+@ObjectType('ApprovalInstance')
+export class ApprovalInstanceEntity {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(() => ID)
+  id!: string;
+
+  @Column('uuid', { name: 'template_id' })
+  @Field(() => ID)
+  templateId!: string;
+
+  @Column('uuid', { name: 'template_version_id' })
+  @Field(() => ID)
+  templateVersionId!: string;
+
+  @Column('text', { name: 'initiator_member_id' })
+  @Field()
+  initiatorMemberId!: string;
+
+  @Column('jsonb', { name: 'initiator_metadata_snapshot' })
+  initiatorMetadataSnapshot!: Readonly<Record<string, unknown>>;
+
+  @Column('jsonb', { name: 'workflow_snapshot' })
+  workflowSnapshot!: WorkflowDefinition;
+
+  @Column('jsonb', { name: 'form_definition_snapshot' })
+  formDefinitionSnapshot!: Readonly<Record<string, unknown>>;
+
+  @Column('jsonb', { name: 'form_data' })
+  formData!: Readonly<Record<string, unknown>>;
+
+  @Column('text')
+  @Field(() => ApprovalInstanceStateEnum)
+  state!: ApprovalInstanceStateEnum;
+
+  @Column('text')
+  @Field()
+  title!: string;
+
+  @Column('timestamptz', { name: 'started_at' })
+  @Field()
+  startedAt!: Date;
+
+  @Column('timestamptz', { name: 'completed_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  completedAt!: Date | null;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  @Field()
+  createdAt!: Date;
+
+  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
+  @Field()
+  updatedAt!: Date;
+
+  @Field(() => String)
+  get initiatorMetadataSnapshotJson(): string {
+    return JSON.stringify(this.initiatorMetadataSnapshot);
+  }
+
+  @Field(() => String)
+  get workflowSnapshotJson(): string {
+    return JSON.stringify(this.workflowSnapshot);
+  }
+
+  @Field(() => String)
+  get formDefinitionSnapshotJson(): string {
+    return JSON.stringify(this.formDefinitionSnapshot);
+  }
+
+  @Field(() => String)
+  get formDataJson(): string {
+    return JSON.stringify(this.formData);
+  }
+}

package/src/lib/workflow-engine/dto/cancel-approval-instance.input.ts

@@ -0,0 +1,18 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+@InputType()
+export class CancelApprovalInstanceInput {
+  @Field()
+  @IsUUID()
+  instanceId!: string;
+
+  @Field()
+  @IsString()
+  cancelledByMemberId!: string;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  comment!: string | null;
+}

package/src/lib/workflow-engine/dto/decide-task.input.ts

@@ -0,0 +1,33 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsEnum, IsOptional, IsString, IsUUID } from 'class-validator';
+import { TaskDecisionActionEnum } from '../workflow-engine.enums';
+
+@InputType()
+export class DecideTaskInput {
+  @Field()
+  @IsUUID()
+  taskId!: string;
+
+  @Field()
+  @IsString()
+  decidedByMemberId!: string;
+
+  @Field(() => TaskDecisionActionEnum)
+  @IsEnum(TaskDecisionActionEnum)
+  action!: TaskDecisionActionEnum;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  comment?: string | null;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  returnToNodeId?: string | null;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  transferToMemberId?: string | null;
+}

package/src/lib/workflow-engine/dto/dry-run-approval-workflow.input.ts

@@ -0,0 +1,22 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsOptional, IsString } from 'class-validator';
+
+@InputType()
+export class DryRunApprovalWorkflowInput {
+  @Field()
+  @IsString()
+  workflowDefinitionJson!: string;
+
+  @Field()
+  @IsString()
+  formDataJson!: string;
+
+  @Field()
+  @IsString()
+  initiatorMemberId!: string;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  initiatorMetadataSnapshotJson!: string | null;
+}

package/src/lib/workflow-engine/dto/resubmit-approval-instance.input.ts

@@ -0,0 +1,22 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+@InputType()
+export class ResubmitApprovalInstanceInput {
+  @Field()
+  @IsUUID()
+  instanceId!: string;
+
+  @Field()
+  @IsString()
+  initiatorMemberId!: string;
+
+  @Field()
+  @IsString()
+  formDataJson!: string;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  title!: string | null;
+}

package/src/lib/workflow-engine/dto/submit-approval-instance.input.ts

@@ -0,0 +1,27 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+@InputType()
+export class SubmitApprovalInstanceInput {
+  @Field()
+  @IsUUID()
+  templateId!: string;
+
+  @Field()
+  @IsString()
+  initiatorMemberId!: string;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  initiatorMetadataSnapshotJson!: string | null;
+
+  @Field()
+  @IsString()
+  formDataJson!: string;
+
+  @Field(() => String, { nullable: true })
+  @IsOptional()
+  @IsString()
+  title!: string | null;
+}

package/src/lib/workflow-engine/task-candidate.entity.ts

@@ -0,0 +1,56 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import { TaskCandidateStatusEnum } from './workflow-engine.enums';
+
+@Entity('task_candidates')
+@ObjectType('TaskCandidate')
+export class TaskCandidateEntity {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(() => ID)
+  id!: string;
+
+  @Column('uuid', { name: 'task_id' })
+  @Field(() => ID)
+  taskId!: string;
+
+  @Column('text', { name: 'member_id' })
+  @Field()
+  memberId!: string;
+
+  @Column('text', { name: 'original_member_id' })
+  @Field()
+  originalMemberId!: string;
+
+  @Column('text', { name: 'source_type' })
+  @Field()
+  sourceType!: string;
+
+  @Column('jsonb', { name: 'delegation_chain' })
+  delegationChain!: readonly Readonly<Record<string, unknown>>[];
+
+  @Column('text')
+  @Field(() => TaskCandidateStatusEnum)
+  status!: TaskCandidateStatusEnum;
+
+  @Column('timestamptz', { name: 'claimed_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  claimedAt!: Date | null;
+
+  @Column('timestamptz', { name: 'decided_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  decidedAt!: Date | null;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  @Field()
+  createdAt!: Date;
+
+  @Field(() => String)
+  get delegationChainJson(): string {
+    return JSON.stringify(this.delegationChain);
+  }
+}

package/src/lib/workflow-engine/task-decision.entity.ts

@@ -0,0 +1,43 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { TaskDecisionActionEnum } from './workflow-engine.enums';
+
+@Entity('task_decisions')
+@ObjectType('TaskDecision')
+export class TaskDecisionEntity {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(() => ID)
+  id!: string;
+
+  @Column('uuid', { name: 'task_id' })
+  @Field(() => ID)
+  taskId!: string;
+
+  @Column('text', { name: 'decided_by_member_id' })
+  @Field()
+  decidedByMemberId!: string;
+
+  @Column('text')
+  @Field(() => TaskDecisionActionEnum)
+  action!: TaskDecisionActionEnum;
+
+  @Column('text', { nullable: true })
+  @Field(() => String, { nullable: true })
+  comment!: string | null;
+
+  @Column('text', { name: 'return_to_node_id', nullable: true })
+  @Field(() => String, { nullable: true })
+  returnToNodeId!: string | null;
+
+  @Column('text', { name: 'transfer_to_member_id', nullable: true })
+  @Field(() => String, { nullable: true })
+  transferToMemberId!: string | null;
+
+  @Column('uuid', { name: 'signature_id', nullable: true })
+  @Field(() => ID, { nullable: true })
+  signatureId!: string | null;
+
+  @Column('timestamptz', { name: 'decided_at' })
+  @Field()
+  decidedAt!: Date;
+}

package/src/lib/workflow-engine/task.entity.ts

@@ -0,0 +1,85 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import {
+  TaskAssignmentTypeEnum,
+  TaskStatusEnum,
+} from './workflow-engine.enums';
+
+@Entity('tasks')
+@ObjectType('Task')
+export class TaskEntity {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(() => ID)
+  id!: string;
+
+  @Column('uuid', { name: 'instance_id' })
+  @Field(() => ID)
+  instanceId!: string;
+
+  @Column('uuid', { name: 'token_id' })
+  @Field(() => ID)
+  tokenId!: string;
+
+  @Column('text', { name: 'node_id' })
+  @Field()
+  nodeId!: string;
+
+  @Column('text', { name: 'original_assignee_member_id', nullable: true })
+  @Field(() => String, { nullable: true })
+  originalAssigneeMemberId!: string | null;
+
+  @Column('text', { name: 'assignee_member_id', nullable: true })
+  @Field(() => String, { nullable: true })
+  assigneeMemberId!: string | null;
+
+  @Column('text', {
+    default: TaskAssignmentTypeEnum.DIRECT_MEMBER,
+    name: 'assignment_type',
+  })
+  @Field(() => TaskAssignmentTypeEnum)
+  assignmentType!: TaskAssignmentTypeEnum;
+
+  @Column('jsonb', { default: { type: 'SINGLE' }, name: 'decision_policy_snapshot' })
+  decisionPolicySnapshot!: Readonly<Record<string, unknown>>;
+
+  @Column('jsonb', { name: 'delegation_chain' })
+  delegationChain!: readonly Readonly<Record<string, unknown>>[];
+
+  @Column('text')
+  @Field(() => TaskStatusEnum)
+  status!: TaskStatusEnum;
+
+  @Column('timestamptz', { name: 'sla_due_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  slaDueAt!: Date | null;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  @Field()
+  createdAt!: Date;
+
+  @Column('timestamptz', { name: 'opened_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  openedAt!: Date | null;
+
+  @Column('timestamptz', { name: 'completed_at', nullable: true })
+  @Field(() => Date, { nullable: true })
+  completedAt!: Date | null;
+
+  @Field(() => String)
+  get delegationChainJson(): string {
+    return JSON.stringify(this.delegationChain);
+  }
+
+  @Field(() => String)
+  get decisionPolicySnapshotJson(): string {
+    return JSON.stringify(this.decisionPolicySnapshot);
+  }
+
+  @Field(() => [String])
+  candidateMemberIds: readonly string[] = [];
+}

package/src/lib/workflow-engine/workflow-condition-evaluator.ts

@@ -0,0 +1,168 @@
+import {
+  WorkflowEdge,
+  WorkflowEdgeConditionOperator,
+} from '@rytass/bpm-core-shared/workflow';
+
+export type WorkflowConditionContext = Readonly<{
+  formData: Readonly<Record<string, unknown>>;
+}>;
+
+export function evaluateWorkflowEdgeCondition(
+  edge: WorkflowEdge,
+  context: WorkflowConditionContext,
+): boolean {
+  const fieldKey = edge.data.conditionFieldKey;
+  const operator = edge.data.conditionOperator;
+
+  if (!fieldKey || !operator) {
+    return false;
+  }
+
+  const actualValue = context.formData[fieldKey];
+
+  if (operator === 'IS_FILLED') {
+    return !isEmptyWorkflowValue(actualValue);
+  }
+
+  if (operator === 'IS_EMPTY') {
+    return isEmptyWorkflowValue(actualValue);
+  }
+
+  const expectedValue = edge.data.conditionValue;
+
+  if (typeof expectedValue === 'undefined') {
+    return false;
+  }
+
+  return compareWorkflowValues(actualValue, operator, expectedValue);
+}
+
+function compareWorkflowValues(
+  actualValue: unknown,
+  operator: WorkflowEdgeConditionOperator,
+  expectedValue: string,
+): boolean {
+  if (Array.isArray(actualValue)) {
+    return compareArrayValue(actualValue, operator, expectedValue);
+  }
+
+  if (operator === 'EQUALS') {
+    return normalizeWorkflowValue(actualValue) ===
+      normalizeExpectedValue(actualValue, expectedValue);
+  }
+
+  if (operator === 'NOT_EQUALS') {
+    return normalizeWorkflowValue(actualValue) !==
+      normalizeExpectedValue(actualValue, expectedValue);
+  }
+
+  return compareOrderedValue(actualValue, operator, expectedValue);
+}
+
+function compareArrayValue(
+  actualValue: readonly unknown[],
+  operator: WorkflowEdgeConditionOperator,
+  expectedValue: string,
+): boolean {
+  const includesExpectedValue = actualValue
+    .map((value) => normalizeWorkflowValue(value))
+    .includes(expectedValue);
+
+  if (operator === 'EQUALS') {
+    return includesExpectedValue;
+  }
+
+  if (operator === 'NOT_EQUALS') {
+    return !includesExpectedValue;
+  }
+
+  return false;
+}
+
+function compareOrderedValue(
+  actualValue: unknown,
+  operator: WorkflowEdgeConditionOperator,
+  expectedValue: string,
+): boolean {
+  const actualNumber = readFiniteNumber(actualValue);
+  const expectedNumber = readFiniteNumber(expectedValue);
+  const actualComparable =
+    actualNumber !== null ? actualNumber : normalizeWorkflowValue(actualValue);
+  const expectedComparable =
+    actualNumber !== null && expectedNumber !== null
+      ? expectedNumber
+      : expectedValue;
+
+  if (operator === 'GREATER_THAN') {
+    return actualComparable > expectedComparable;
+  }
+
+  if (operator === 'GREATER_THAN_OR_EQUALS') {
+    return actualComparable >= expectedComparable;
+  }
+
+  if (operator === 'LESS_THAN') {
+    return actualComparable < expectedComparable;
+  }
+
+  if (operator === 'LESS_THAN_OR_EQUALS') {
+    return actualComparable <= expectedComparable;
+  }
+
+  return false;
+}
+
+function isEmptyWorkflowValue(value: unknown): boolean {
+  if (value === null || typeof value === 'undefined') {
+    return true;
+  }
+
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  return typeof value === 'string' ? value.trim() === '' : false;
+}
+
+function normalizeWorkflowValue(value: unknown): string | number | boolean {
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
+  ) {
+    return value;
+  }
+
+  return String(value ?? '');
+}
+
+function normalizeExpectedValue(
+  actualValue: unknown,
+  expectedValue: string,
+): string | number | boolean {
+  if (typeof actualValue === 'boolean') {
+    return expectedValue === 'true';
+  }
+
+  if (typeof actualValue === 'number') {
+    const expectedNumber = Number(expectedValue);
+
+    return Number.isFinite(expectedNumber) ? expectedNumber : expectedValue;
+  }
+
+  return expectedValue;
+}
+
+function readFiniteNumber(value: unknown): number | null {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : null;
+  }
+
+  if (typeof value !== 'string' || !value.trim()) {
+    return null;
+  }
+
+  const numberValue = Number(value);
+
+  return Number.isFinite(numberValue) ? numberValue : null;
+}

package/src/lib/workflow-engine/workflow-dashboard-summary.object.ts

@@ -0,0 +1,22 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('WorkflowDashboardSummary')
+export class WorkflowDashboardSummaryObject {
+  @Field(() => Int)
+  activeInstanceCount!: number;
+
+  @Field(() => Int)
+  completedInstanceCount!: number;
+
+  @Field(() => Int)
+  overdueTaskCount!: number;
+
+  @Field(() => Int)
+  pendingTaskCount!: number;
+
+  @Field(() => Int)
+  rejectedInstanceCount!: number;
+
+  @Field(() => Int)
+  totalInstanceCount!: number;
+}

package/src/lib/workflow-engine/workflow-dry-run.object.ts

@@ -0,0 +1,58 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('WorkflowDryRunStep')
+export class WorkflowDryRunStepObject {
+  @Field()
+  id!: string;
+
+  @Field()
+  nodeId!: string;
+
+  @Field()
+  nodeLabel!: string;
+
+  @Field()
+  nodeType!: string;
+
+  @Field()
+  status!: string;
+
+  @Field(() => String, { nullable: true })
+  edgeId!: string | null;
+
+  @Field(() => String, { nullable: true })
+  edgeLabel!: string | null;
+
+  @Field(() => Boolean, { nullable: true })
+  edgeMatched!: boolean | null;
+
+  @Field(() => String, { nullable: true })
+  edgeReason!: string | null;
+
+  @Field(() => Boolean, { nullable: true })
+  edgeDefault!: boolean | null;
+
+  @Field(() => String, { nullable: true })
+  entryCondition!: string | null;
+
+  @Field(() => Boolean, { nullable: true })
+  entryConditionMatched!: boolean | null;
+
+  @Field(() => String, { nullable: true })
+  assigneeMemberId!: string | null;
+
+  @Field()
+  message!: string;
+}
+
+@ObjectType('WorkflowDryRunResult')
+export class WorkflowDryRunResultObject {
+  @Field()
+  valid!: boolean;
+
+  @Field(() => [String])
+  errors!: readonly string[];
+
+  @Field(() => [WorkflowDryRunStepObject])
+  steps!: readonly WorkflowDryRunStepObject[];
+}