@gadmin2n/schematics 0.0.139 → 0.0.140

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/workflowNodeInstance.controller.ts

@@ -7,9 +7,9 @@ import {
   PageMetaDto,
   PageOptionsDto,
   pick,
-  UserType,
 } from '@gadmin2n/nest-common';
 import {
+  BadRequestException,
   Body,
   Controller,
   Delete,
@@ -34,8 +34,6 @@ import { Prisma } from '@prisma/client';
 import { UseRoles } from 'nest-access-control';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { Logger } from 'winston';
-import { CreateWorkflowNodeInstanceDto } from '../../generated/workflowNodeInstance/dto/create-workflowNodeInstance.dto';
-import { UpdateWorkflowNodeInstanceDto } from '../../generated/workflowNodeInstance/dto/update-workflowNodeInstance.dto';
 import {
   EffectedCount,
   UploadResponse,
@@ -43,10 +41,19 @@ import {
   WorkflowNodeInstanceWhereSelect,
 } from '../../generated/workflowNodeInstance/dto/workflowNodeInstance-types.dto';
 import { WorkflowNodeInstanceEntity } from '../../generated/workflowNodeInstance/entities/workflowNodeInstance.entity';
+import {
+  CreateConfiguredNodeInstanceDto,
+  LegacyCreateWorkflowNodeInstanceDto,
+  UpdateConfiguredNodeInstanceDto,
+} from './workflowNodeInstance.dto';
 import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
 
 import { ConfigService } from '@nestjs/config';
 import { FileInterceptor } from '@nestjs/platform-express';
+import {
+  actorContextFromRequest,
+  AuthenticatedActorRequest,
+} from '../subjectProvider/actor-context.util';
 
 @UseGuards(ACGuard)
 @Controller('workflowNodeInstance')
@@ -58,6 +65,27 @@ export class WorkflowNodeInstanceController {
     @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
   ) {}
 
+  @Patch(':id')
+  @UseRoles({
+    resource: 'workflowNodeInstance',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: WorkflowNodeInstanceEntity })
+  async updateConfigured(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateConfiguredNodeInstanceDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return new WorkflowNodeInstanceEntity(
+      await this.workflowNodeInstanceService.updateConfigured(
+        id,
+        body,
+        this.actorFrom(request),
+      ),
+    );
+  }
+
   @Post('createOne')
   @UseRoles({
     resource: 'workflowNodeInstance',
@@ -66,15 +94,18 @@ export class WorkflowNodeInstanceController {
   })
   @ApiCreatedResponse({ type: WorkflowNodeInstanceEntity })
   async createOne(
-    @Body() body: CreateWorkflowNodeInstanceDto,
+    @Body() body: LegacyCreateWorkflowNodeInstanceDto,
     @ACAttrFilter() acAttrFilter,
-    @Req() request: Request & { user: UserType },
+    @Req() request: AuthenticatedActorRequest,
   ) {
-    body.creator = request.user.username;
+    const configuredInput = this.normalizeLegacyCreate(
+      acAttrFilter(body) as LegacyCreateWorkflowNodeInstanceDto,
+    );
     return new WorkflowNodeInstanceEntity(
-      await this.workflowNodeInstanceService.createOne({
-        data: acAttrFilter(body),
-      }),
+      await this.workflowNodeInstanceService.createConfigured(
+        configuredInput,
+        this.actorFrom(request),
+      ),
     );
   }
 
@@ -136,8 +167,9 @@ export class WorkflowNodeInstanceController {
   @ApiNotFoundResponse({ description: 'Cannot found this record.' })
   async updateUnique(
     @Param('id', ParseIntPipe) id: number,
-    @Body() body: UpdateWorkflowNodeInstanceDto,
+    @Body() body: UpdateConfiguredNodeInstanceDto,
     @ACAttrFilter() acAttrFilter,
+    @Req() request: AuthenticatedActorRequest,
   ) {
     /* 
     const origin = (await this.workflowNodeInstanceService.findUnique(id, {
@@ -156,13 +188,73 @@ export class WorkflowNodeInstanceController {
     // 其他个性化逻辑
     */
 
-    const item = await this.workflowNodeInstanceService.updateUnique(
+    const item = await this.workflowNodeInstanceService.updateConfigured(
       id,
       acAttrFilter(body),
+      this.actorFrom(request),
     );
     return new WorkflowNodeInstanceEntity(acAttrFilter(item));
   }
 
+  private actorFrom(request: AuthenticatedActorRequest) {
+    return actorContextFromRequest(request);
+  }
+
+  private normalizeLegacyCreate(
+    body: LegacyCreateWorkflowNodeInstanceDto,
+  ): CreateConfiguredNodeInstanceDto {
+    const rawNodeTypeId = body.nodeTypeId ?? body.nodeType?.connect?.id;
+    const nodeTypeId = this.parsePositiveNodeTypeId(rawNodeTypeId);
+
+    let config: unknown = body.config;
+    if (typeof config === 'string') {
+      try {
+        config = JSON.parse(config);
+      } catch {
+        throw new BadRequestException('config must be a JSON object');
+      }
+    }
+    if (
+      config === null ||
+      typeof config !== 'object' ||
+      Array.isArray(config)
+    ) {
+      throw new BadRequestException('config must be a JSON object');
+    }
+
+    return {
+      nodeTypeId,
+      name: body.name,
+      ...(body.description != null && { description: body.description }),
+      config: config as Record<string, unknown>,
+      ...(body.isEnabled !== undefined && { isEnabled: body.isEnabled }),
+    };
+  }
+
+  private parsePositiveNodeTypeId(value: unknown): number {
+    if (typeof value === 'number') {
+      if (Number.isSafeInteger(value) && value > 0) return value;
+      throw new BadRequestException('nodeTypeId must be a positive integer');
+    }
+
+    let integerValue: bigint;
+    if (typeof value === 'bigint') {
+      integerValue = value;
+    } else if (typeof value === 'string' && /^\d+$/.test(value)) {
+      integerValue = BigInt(value);
+    } else {
+      throw new BadRequestException('nodeTypeId must be a positive integer');
+    }
+
+    if (
+      integerValue <= BigInt(0) ||
+      integerValue > BigInt(Number.MAX_SAFE_INTEGER)
+    ) {
+      throw new BadRequestException('nodeTypeId must be a positive integer');
+    }
+    return Number(integerValue);
+  }
+
   @Delete('deleteUnique/:id')
   @UseRoles({
     resource: 'workflowNodeInstance',

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/workflowNodeInstance.dto.ts

@@ -0,0 +1,98 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsDefined,
+  IsInt,
+  IsObject,
+  IsOptional,
+  IsString,
+  ValidateIf,
+  ValidateNested,
+} from 'class-validator';
+
+class LegacyWorkflowNodeTypeConnectDto {
+  @IsDefined()
+  id: unknown;
+}
+
+class LegacyWorkflowNodeTypeRelationDto {
+  @IsDefined()
+  @ValidateNested()
+  @Type(() => LegacyWorkflowNodeTypeConnectDto)
+  connect: LegacyWorkflowNodeTypeConnectDto;
+}
+
+export class LegacyCreateWorkflowNodeInstanceDto {
+  @ValidateIf((body) => body.nodeTypeId === undefined)
+  @IsDefined()
+  @ValidateNested()
+  @Type(() => LegacyWorkflowNodeTypeRelationDto)
+  nodeType?: LegacyWorkflowNodeTypeRelationDto;
+
+  @ValidateIf((body) => body.nodeType === undefined)
+  @IsDefined()
+  nodeTypeId?: unknown;
+
+  @IsString()
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string | null;
+
+  @Transform(({ value }) => {
+    if (typeof value !== 'string') return value;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  })
+  @IsObject({ message: 'config must be a JSON object' })
+  config: Record<string, unknown>;
+
+  @IsOptional()
+  @IsBoolean()
+  isEnabled?: boolean;
+
+  @IsOptional()
+  @IsString()
+  creator?: string;
+}
+
+export class CreateConfiguredNodeInstanceDto {
+  @IsInt()
+  nodeTypeId: number;
+
+  @IsString()
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsObject()
+  config: Record<string, unknown>;
+
+  @IsOptional()
+  @IsBoolean()
+  isEnabled?: boolean;
+}
+
+export class UpdateConfiguredNodeInstanceDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string | null;
+
+  @IsOptional()
+  @IsBoolean()
+  isEnabled?: boolean;
+
+  @IsOptional()
+  @IsObject()
+  config?: Record<string, unknown>;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/workflowNodeInstance.module.ts

@@ -1,8 +1,11 @@
 import { Module } from '@nestjs/common';
+import { SubjectProviderModule } from '../subjectProvider/subjectProvider.module';
+import { WorkflowConfigModule } from '../workflowConfig/workflowConfig.module';
 import { WorkflowNodeInstanceController } from './workflowNodeInstance.controller';
 import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
 
 @Module({
+  imports: [WorkflowConfigModule, SubjectProviderModule],
   controllers: [WorkflowNodeInstanceController],
   providers: [WorkflowNodeInstanceService],
   exports: [WorkflowNodeInstanceService],

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/workflowNodeInstance.service.spec.ts

@@ -1,18 +1,16 @@
 /// <reference types="jest" />
-import { ConfigService } from '@nestjs/config';
-import { Test, TestingModule } from '@nestjs/testing';
-import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
-
-// Mock nestjs-prisma 模块
-jest.mock('nestjs-prisma', () => ({
-  PrismaService: jest.fn(),
-}));
-
-import { PrismaService } from 'nestjs-prisma';
 import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
 
-// Mock PrismaService
 const mockPrismaService = {
+  audit: {
+    create: jest.fn(),
+  },
+  workflowNodeType: {
+    findUnique: jest.fn(),
+  },
+  integrationConnection: {
+    findUnique: jest.fn(),
+  },
   workflowNodeInstance: {
     create: jest.fn(),
     createMany: jest.fn(),
@@ -28,18 +26,16 @@ const mockPrismaService = {
   },
 };
 
-// Mock Logger
-const mockLogger = {
-  child: jest.fn().mockReturnThis(),
-  info: jest.fn(),
-  error: jest.fn(),
-  warn: jest.fn(),
-  debug: jest.fn(),
+const mockNodeConfigValidator = {
+  validateOrThrow: jest.fn(),
 };
 
-// Mock ConfigService
-const mockConfigService = {
-  get: jest.fn(),
+const mockWidgetCatalog = {
+  assertUiSchemaSupported: jest.fn(),
+};
+
+const mockSubjectConfigValidator = {
+  validateSubjects: jest.fn(),
 };
 
 describe('WorkflowNodeInstanceService', () => {
@@ -50,17 +46,11 @@ describe('WorkflowNodeInstanceService', () => {
     // 每个测试前重置所有 mock
     jest.clearAllMocks();
 
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        WorkflowNodeInstanceService,
-        { provide: PrismaService, useValue: mockPrismaService },
-        { provide: ConfigService, useValue: mockConfigService },
-        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
-      ],
-    }).compile();
-
-    service = module.get<WorkflowNodeInstanceService>(
-      WorkflowNodeInstanceService,
+    service = new WorkflowNodeInstanceService(
+      mockPrismaService as any,
+      mockNodeConfigValidator as any,
+      mockWidgetCatalog as any,
+      mockSubjectConfigValidator as any,
     );
     prisma = mockPrismaService;
   });
@@ -69,45 +59,69 @@ describe('WorkflowNodeInstanceService', () => {
     expect(service).toBeDefined();
   });
 
-  describe('createOne', () => {
-    it('should create a single workflowNodeInstance record', async () => {
-      const createArgs = {
-        data: {
-          name: 'test_name',
-          config: {},
-          creator: 'test_creator',
-          code: 'test_code',
-          description: 'test_description',
-        },
-      } as any;
-      const expectedResult = { id: 1, ...createArgs.data };
+  describe('createConfigured', () => {
+    const nodeType = {
+      id: BigInt(1),
+      runtimeKey: 'manual',
+      schemaVersion: 1,
+      configSchema: { type: 'object' },
+      uiSchema: {},
+    };
+    const input = {
+      nodeTypeId: 1,
+      name: '测试节点',
+      description: '测试描述',
+      config: {},
+      isEnabled: true,
+    };
+    const actor = { userId: 'user-1', username: 'tester' };
+
+    it('should validate and create a configured node instance', async () => {
+      const expectedResult = {
+        id: BigInt(1),
+        ...input,
+        nodeTypeId: BigInt(1),
+        creator: 'tester',
+      };
 
+      prisma.workflowNodeType.findUnique.mockResolvedValue(nodeType);
       prisma.workflowNodeInstance.create.mockResolvedValue(expectedResult);
+      prisma.audit.create.mockResolvedValue({});
 
-      const result = await service.createOne(createArgs);
+      const result = await service.createConfigured(input, actor);
 
-      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledWith(
-        createArgs,
+      expect(mockNodeConfigValidator.validateOrThrow).toHaveBeenCalledWith(
+        '1:1',
+        nodeType.configSchema,
+        input.config,
       );
-      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledTimes(1);
+      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledWith({
+        data: {
+          nodeTypeId: BigInt(1),
+          name: input.name,
+          description: input.description,
+          config: input.config,
+          isEnabled: true,
+          creator: 'tester',
+        },
+      });
+      expect(prisma.audit.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          action: 'CREATE_NODE_INSTANCE',
+          resourceId: '1',
+          creator: 'tester',
+        }),
+      });
       expect(result).toEqual(expectedResult);
     });
 
     it('should throw error when create fails', async () => {
-      const createArgs = {
-        data: {
-          name: 'test_name',
-          config: {},
-          creator: 'test_creator',
-          code: 'test_code',
-          description: 'test_description',
-        },
-      } as any;
       const error = new Error('Database connection failed');
 
+      prisma.workflowNodeType.findUnique.mockResolvedValue(nodeType);
       prisma.workflowNodeInstance.create.mockRejectedValue(error);
 
-      await expect(service.createOne(createArgs)).rejects.toThrow(
+      await expect(service.createConfigured(input, actor)).rejects.toThrow(
         'Database connection failed',
       );
     });
@@ -119,14 +133,12 @@ describe('WorkflowNodeInstanceService', () => {
         {
           name: 'test_name',
           config: {},
-          creator: 'test_creator',
           code: 'test_code',
           description: 'test_description',
         },
         {
           name: 'test_name',
           config: {},
-          creator: 'test_creator',
           code: 'test_code',
           description: 'test_description',
         },
@@ -215,7 +227,6 @@ describe('WorkflowNodeInstanceService', () => {
       const data = {
         name: 'test_name',
         config: {},
-        creator: 'test_creator',
         code: 'test_code',
         description: 'test_description',
       } as any;
@@ -240,7 +251,6 @@ describe('WorkflowNodeInstanceService', () => {
         data: {
           name: 'test_name',
           config: {},
-          creator: 'test_creator',
           code: 'test_code',
           description: 'test_description',
         },

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/workflowNodeInstance.service.ts

@@ -1,25 +1,159 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { Injectable, NotFoundException } from '@nestjs/common';
 import { Prisma, WorkflowNodeInstance } from '@prisma/client';
-import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { PrismaService } from 'nestjs-prisma';
-import { Logger } from 'winston';
 
-import { ConfigService } from '@nestjs/config';
+import { ActorContext } from '../subjectProvider/subject-provider.types';
+import { NodeConfigValidatorService } from '../workflowConfig/node-config-validator.service';
+import { JsonSchema } from '../workflowConfig/schema.types';
+import { SubjectConfigValidatorService } from '../workflowConfig/subject-config-validator.service';
+import { WidgetCatalogService } from '../workflowConfig/widget-catalog.service';
+import {
+  CreateConfiguredNodeInstanceDto,
+  UpdateConfiguredNodeInstanceDto,
+} from './workflowNodeInstance.dto';
 
 @Injectable()
 export class WorkflowNodeInstanceService {
   constructor(
     private prisma: PrismaService,
-    private readonly config: ConfigService,
-    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+    private readonly nodeConfigValidator: NodeConfigValidatorService,
+    private readonly widgetCatalog: WidgetCatalogService,
+    private readonly subjectConfigValidator: SubjectConfigValidatorService,
   ) {}
 
-  async createOne(
-    workflowNodeInstanceCreateArgs: Prisma.WorkflowNodeInstanceCreateArgs,
+  async createConfigured(
+    input: CreateConfiguredNodeInstanceDto,
+    actor: ActorContext,
   ) {
-    return await this.prisma.workflowNodeInstance.create(
-      workflowNodeInstanceCreateArgs,
+    const nodeType = await this.prisma.workflowNodeType.findUnique({
+      where: { id: BigInt(input.nodeTypeId) },
+      select: {
+        id: true,
+        runtimeKey: true,
+        schemaVersion: true,
+        configSchema: true,
+        uiSchema: true,
+      },
+    });
+    if (!nodeType) throw new NotFoundException('Node type not found');
+
+    await this.validateConfig(nodeType, input.config, actor);
+
+    const config = input.config as Prisma.InputJsonValue;
+    const creator = this.creatorFrom(actor);
+    const instance = await this.prisma.workflowNodeInstance.create({
+      data: {
+        nodeTypeId: BigInt(input.nodeTypeId),
+        name: input.name,
+        description: input.description,
+        config,
+        isEnabled: input.isEnabled ?? true,
+        creator,
+      },
+    });
+    await this.createAudit('CREATE_NODE_INSTANCE', instance.id, creator);
+    return instance;
+  }
+
+  async updateConfigured(
+    instanceId: number,
+    input: UpdateConfiguredNodeInstanceDto,
+    actor: ActorContext,
+  ) {
+    const id = BigInt(instanceId);
+    const instance = await this.prisma.workflowNodeInstance.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        nodeType: {
+          select: {
+            id: true,
+            runtimeKey: true,
+            schemaVersion: true,
+            configSchema: true,
+            uiSchema: true,
+          },
+        },
+      },
+    });
+    if (!instance) throw new NotFoundException('Node instance not found');
+
+    if (input.config !== undefined)
+      await this.validateConfig(instance.nodeType, input.config, actor);
+    const data = {
+      ...(input.name !== undefined && { name: input.name }),
+      ...(input.description !== undefined && {
+        description: input.description,
+      }),
+      ...(input.isEnabled !== undefined && { isEnabled: input.isEnabled }),
+      ...(input.config !== undefined && {
+        config: input.config as Prisma.InputJsonValue,
+      }),
+    };
+    const updated = await this.prisma.workflowNodeInstance.update({
+      where: { id: BigInt(instanceId) },
+      data,
+    });
+    await this.createAudit(
+      'UPDATE_NODE_INSTANCE',
+      updated.id,
+      this.creatorFrom(actor),
+    );
+    return updated;
+  }
+
+  private async validateConfig(
+    nodeType: {
+      id: bigint;
+      runtimeKey: string;
+      schemaVersion: number;
+      configSchema: Prisma.JsonValue;
+      uiSchema: Prisma.JsonValue;
+    },
+    config: unknown,
+    actor: ActorContext,
+  ): Promise<void> {
+    const schemaKey = `${nodeType.id}:${nodeType.schemaVersion}`;
+    const configSchema = nodeType.configSchema as JsonSchema;
+
+    this.nodeConfigValidator.validateOrThrow(schemaKey, configSchema, config);
+    this.widgetCatalog.assertUiSchemaSupported(nodeType.uiSchema);
+    await this.subjectConfigValidator.validateSubjects(
+      configSchema,
+      config,
+      actor,
     );
+    if (nodeType.runtimeKey === 'http_request') {
+      const connectionRef = (config as Record<string, unknown>)?.connectionRef;
+      const connection =
+        typeof connectionRef === 'string'
+          ? await this.prisma.integrationConnection.findUnique({
+              where: { code: connectionRef },
+              select: { isEnabled: true },
+            })
+          : null;
+      if (!connection?.isEnabled)
+        throw new NotFoundException(
+          'HTTP Request Connection was not found or is disabled',
+        );
+    }
+  }
+
+  private creatorFrom(actor: ActorContext): string {
+    return actor.username ?? actor.userId;
+  }
+
+  private async createAudit(action: string, instanceId: bigint, actor: string) {
+    await this.prisma.audit.create({
+      data: {
+        creator: actor,
+        authorName: actor,
+        action,
+        resource: 'workflowNodeInstance',
+        resourceId: String(instanceId),
+        data: JSON.stringify({ instanceId: String(instanceId) }),
+      },
+    });
   }
 
   async createMany(data: Prisma.WorkflowNodeInstanceCreateManyArgs['data']) {
@@ -150,7 +284,10 @@ export class WorkflowNodeInstanceService {
       if (!dsl?.nodes || !Array.isArray(dsl.nodes)) continue;
 
       for (const node of dsl.nodes) {
-        if (node.instanceRef?.instanceId === targetId) {
+        if (
+          node.source?.instanceId === targetId ||
+          node.instanceRef?.instanceId === targetId
+        ) {
           results.push({
             workflowId: String(wf.id),
             workflowName: wf.name,