@gadmin2n/schematics 0.0.72 → 0.0.75

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

@@ -0,0 +1,505 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { PrismaService } from 'nestjs-prisma';
+
+@Injectable()
+export class WorkflowService {
+  constructor(private prisma: PrismaService) {}
+
+  async findMany(params: {
+    status?: string;
+    instanceStatus?: string;
+    name?: string;
+    skip?: number;
+    limit?: number;
+  }) {
+    const where: Prisma.WorkflowWhereInput = {};
+    if (params.status) {
+      where.status = params.status as any;
+    }
+    if (params.instanceStatus) {
+      where.instances = { some: { status: params.instanceStatus as any } };
+    }
+    if (params.name) {
+      where.name = { contains: params.name, mode: 'insensitive' };
+    }
+
+    const [items, total] = await Promise.all([
+      this.prisma.workflow.findMany({
+        where,
+        orderBy: { updatedAt: 'desc' },
+        skip: params.skip || 0,
+        take: params.limit || 20,
+        include: {
+          versions: {
+            orderBy: { version: 'desc' },
+            take: 1,
+            select: { version: true, changeSummary: true },
+          },
+          _count: { select: { instances: true } },
+        },
+      }),
+      this.prisma.workflow.count({ where }),
+    ]);
+
+    // Add per-status instance counts
+    const workflowIds = items.map((w) => w.id);
+    const instanceCounts = workflowIds.length
+      ? await this.prisma.workflowInstance.groupBy({
+          by: ['workflowId', 'status'],
+          where: { workflowId: { in: workflowIds } },
+          _count: true,
+        })
+      : [];
+
+    const runsMap = new Map<
+      bigint,
+      { pending: number; running: number; completed: number; failed: number }
+    >();
+    for (const row of instanceCounts) {
+      if (!runsMap.has(row.workflowId)) {
+        runsMap.set(row.workflowId, {
+          pending: 0,
+          running: 0,
+          completed: 0,
+          failed: 0,
+        });
+      }
+      const entry = runsMap.get(row.workflowId)!;
+      const key = row.status.toLowerCase() as keyof typeof entry;
+      if (key in entry) entry[key] = row._count;
+    }
+
+    // Get last run time for each workflow
+    const lastRuns = workflowIds.length
+      ? await this.prisma.workflowInstance.findMany({
+          where: { workflowId: { in: workflowIds } },
+          orderBy: { createdAt: 'desc' },
+          distinct: ['workflowId'],
+          select: { workflowId: true, createdAt: true, status: true },
+        })
+      : [];
+    const lastRunMap = new Map(lastRuns.map((r) => [r.workflowId, r]));
+
+    const enrichedItems = items.map((item) => ({
+      ...item,
+      runs: runsMap.get(item.id) || {
+        pending: 0,
+        running: 0,
+        completed: 0,
+        failed: 0,
+      },
+      lastRun: lastRunMap.get(item.id)?.createdAt || null,
+    }));
+
+    return { items: enrichedItems, total };
+  }
+
+  async findOne(id: bigint) {
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { id },
+      include: {
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+        },
+      },
+    });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    return workflow;
+  }
+
+  async create(
+    data: { name: string; description?: string; dsl?: any },
+    creator: string,
+  ) {
+    const workflow = await this.prisma.workflow.create({
+      data: {
+        name: data.name,
+        description: data.description,
+        dsl: data.dsl || null,
+        creator,
+      },
+    });
+
+    return workflow;
+  }
+
+  async update(id: bigint, data: { name?: string; description?: string }) {
+    const workflow = await this.prisma.workflow.findUnique({ where: { id } });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    return this.prisma.workflow.update({ where: { id }, data });
+  }
+
+  async saveDraft(id: bigint, dsl: any) {
+    const workflow = await this.prisma.workflow.findUnique({ where: { id } });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    return this.prisma.workflow.update({
+      where: { id },
+      data: { dsl, status: 'DRAFT' },
+    });
+  }
+
+  async toggleEnabled(id: bigint, enabled: boolean) {
+    const workflow = await this.prisma.workflow.findUnique({ where: { id } });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    return this.prisma.workflow.update({
+      where: { id },
+      data: { isEnabled: enabled },
+    });
+  }
+
+  async remove(id: bigint) {
+    const workflow = await this.prisma.workflow.findUnique({ where: { id } });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    return this.prisma.workflow.delete({ where: { id } });
+  }
+
+  async getVersions(workflowId: bigint) {
+    return this.prisma.workflowVersion.findMany({
+      where: { workflowId },
+      orderBy: { version: 'desc' },
+      select: {
+        id: true,
+        version: true,
+        prompt: true,
+        changeSummary: true,
+        creator: true,
+        createdAt: true,
+      },
+    });
+  }
+
+  async getVersionDsl(workflowId: bigint, version: number) {
+    const v = await this.prisma.workflowVersion.findUnique({
+      where: { workflowId_version: { workflowId, version } },
+    });
+    if (!v) throw new NotFoundException('Version not found');
+    return v;
+  }
+
+  async publish(
+    workflowId: bigint,
+    data: { changeSummary: string },
+    creator: string,
+  ) {
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { id: workflowId },
+    });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+
+    // Use workflow.dsl if available; otherwise fall back to latest version's DSL
+    let dslToPublish = workflow.dsl;
+    if (!dslToPublish) {
+      const latestVersion = await this.prisma.workflowVersion.findFirst({
+        where: { workflowId },
+        orderBy: { version: 'desc' },
+        select: { dsl: true },
+      });
+      dslToPublish = latestVersion?.dsl ?? null;
+    }
+    if (!dslToPublish) {
+      throw new NotFoundException('No draft DSL to publish');
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      const lastVersion = await tx.workflowVersion.findFirst({
+        where: { workflowId },
+        orderBy: { version: 'desc' },
+        select: { version: true },
+      });
+      const nextVersion = (lastVersion?.version ?? 0) + 1;
+
+      const version = await tx.workflowVersion.create({
+        data: {
+          workflowId,
+          version: nextVersion,
+          dsl: dslToPublish,
+          prompt: data.changeSummary,
+          changeSummary: data.changeSummary,
+          creator,
+        },
+      });
+
+      await tx.workflow.update({
+        where: { id: workflowId },
+        data: { status: 'PUBLISHED' },
+      });
+
+      return version;
+    });
+  }
+
+  async getStats(workflowId: bigint) {
+    const [running, failed, completed, total] = await Promise.all([
+      this.prisma.workflowInstance.count({
+        where: { workflowId, status: 'RUNNING' },
+      }),
+      this.prisma.workflowInstance.count({
+        where: { workflowId, status: 'FAILED' },
+      }),
+      this.prisma.workflowInstance.count({
+        where: { workflowId, status: 'COMPLETED' },
+      }),
+      this.prisma.workflowInstance.count({ where: { workflowId } }),
+    ]);
+    return { running, failed, completed, total };
+  }
+
+  async getOverview() {
+    const now = new Date();
+    const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+    const [
+      totalAll,
+      total24h,
+      completedAll,
+      completed24h,
+      failedAll,
+      failed24h,
+      running,
+      pending,
+    ] = await Promise.all([
+      this.prisma.workflowInstance.count(),
+      this.prisma.workflowInstance.count({
+        where: { createdAt: { gte: last24h } },
+      }),
+      this.prisma.workflowInstance.count({ where: { status: 'COMPLETED' } }),
+      this.prisma.workflowInstance.count({
+        where: { status: 'COMPLETED', createdAt: { gte: last24h } },
+      }),
+      this.prisma.workflowInstance.count({ where: { status: 'FAILED' } }),
+      this.prisma.workflowInstance.count({
+        where: { status: 'FAILED', createdAt: { gte: last24h } },
+      }),
+      this.prisma.workflowInstance.count({ where: { status: 'RUNNING' } }),
+      this.prisma.workflowInstance.count({ where: { status: 'PENDING' } }),
+    ]);
+
+    // Success rate calculation
+    const denomAll = completedAll + failedAll;
+    const denom24h = completed24h + failed24h;
+    const successRateAll = denomAll > 0 ? (completedAll / denomAll) * 100 : 0;
+    const successRate24h = denom24h > 0 ? (completed24h / denom24h) * 100 : 0;
+
+    // AVG/P95 duration via raw SQL
+    const durationAll = await this.prisma.$queryRaw<
+      { avg: number | null; p95: number | null }[]
+    >`
+      SELECT
+        AVG(EXTRACT(EPOCH FROM finished_at - started_at)) as avg,
+        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY EXTRACT(EPOCH FROM finished_at - started_at)) as p95
+      FROM t_workflow_instance
+      WHERE status = 'COMPLETED' AND finished_at IS NOT NULL AND started_at IS NOT NULL
+    `;
+
+    const duration24h = await this.prisma.$queryRaw<
+      { avg: number | null; p95: number | null }[]
+    >`
+      SELECT
+        AVG(EXTRACT(EPOCH FROM finished_at - started_at)) as avg,
+        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY EXTRACT(EPOCH FROM finished_at - started_at)) as p95
+      FROM t_workflow_instance
+      WHERE status = 'COMPLETED' AND finished_at IS NOT NULL AND started_at IS NOT NULL
+        AND created_at >= ${last24h}
+    `;
+
+    return {
+      totalRuns: { last24h: total24h, total: totalAll },
+      successRate: {
+        last24h: Math.round(successRate24h * 10) / 10,
+        total: Math.round(successRateAll * 10) / 10,
+      },
+      failed: { last24h: failed24h, total: failedAll },
+      duration: {
+        last24h: {
+          avg: Number(duration24h[0]?.avg) || 0,
+          p95: Number(duration24h[0]?.p95) || 0,
+        },
+        total: {
+          avg: Number(durationAll[0]?.avg) || 0,
+          p95: Number(durationAll[0]?.p95) || 0,
+        },
+      },
+      running,
+      pending,
+    };
+  }
+
+  async getInstances(
+    workflowId: bigint,
+    params: { status?: string; skip?: number; limit?: number },
+  ) {
+    const where: any = { workflowId };
+    if (params.status) where.status = params.status;
+
+    const [items, total] = await Promise.all([
+      this.prisma.workflowInstance.findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+        skip: params.skip || 0,
+        take: params.limit || 20,
+      }),
+      this.prisma.workflowInstance.count({ where }),
+    ]);
+
+    return { items, total };
+  }
+
+  // ─── Execution Methods ──────────────────────────────────────────────────────
+
+  async executeWorkflow(
+    workflowId: bigint,
+    dto: { context?: Record<string, any>; versionId?: number },
+    creator: string,
+    temporalService: any,
+  ) {
+    // Get the workflow and its latest published version
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { id: workflowId },
+      include: {
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+        },
+      },
+    });
+
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    if (workflow.status !== 'PUBLISHED') {
+      throw new Error('Workflow must be published before execution');
+    }
+    if (!workflow.isEnabled) {
+      throw new Error('Workflow is disabled');
+    }
+
+    // Determine which version to use
+    let version;
+    if (dto.versionId) {
+      version = await this.prisma.workflowVersion.findFirst({
+        where: { workflowId, version: dto.versionId },
+      });
+    } else {
+      version = workflow.versions[0];
+    }
+
+    if (!version) throw new NotFoundException('No published version found');
+
+    // Create a WorkflowInstance record
+    const instance = await this.prisma.workflowInstance.create({
+      data: {
+        workflowId,
+        versionId: version.id,
+        status: 'PENDING',
+        context: dto.context || {},
+        creator,
+      },
+    });
+
+    // Start the Temporal workflow
+    const { temporalRunId } = await temporalService.startWorkflow({
+      instanceId: Number(instance.id),
+      workflowId: Number(workflowId),
+      versionId: Number(version.id),
+      dsl: version.dsl,
+      context: dto.context || {},
+    });
+
+    // Update instance with Temporal run ID
+    await this.prisma.workflowInstance.update({
+      where: { id: instance.id },
+      data: { temporalRunId },
+    });
+
+    return {
+      instanceId: instance.id.toString(),
+      temporalRunId,
+      status: 'PENDING',
+    };
+  }
+
+  async getInstanceDetail(instanceId: bigint) {
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+      include: {
+        workflow: { select: { name: true } },
+        nodeExecutions: {
+          orderBy: { createdAt: 'asc' },
+        },
+      },
+    });
+
+    if (!instance) throw new NotFoundException('Instance not found');
+    return instance;
+  }
+
+  async cancelInstance(instanceId: bigint, temporalService: any) {
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+    });
+
+    if (!instance) throw new NotFoundException('Instance not found');
+    if (instance.status !== 'RUNNING' && instance.status !== 'PENDING') {
+      throw new Error('Can only cancel RUNNING or PENDING instances');
+    }
+
+    if (instance.temporalRunId) {
+      await temporalService.cancelWorkflow(instance.temporalRunId);
+    }
+
+    await this.prisma.workflowInstance.update({
+      where: { id: instanceId },
+      data: { status: 'CANCELLED', finishedAt: new Date() },
+    });
+
+    return { success: true };
+  }
+
+  async retryInstance(
+    instanceId: bigint,
+    creator: string,
+    temporalService: any,
+  ) {
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+    });
+
+    if (!instance) throw new NotFoundException('Instance not found');
+    if (instance.status !== 'FAILED') {
+      throw new Error('Can only retry FAILED instances');
+    }
+
+    // Create a new instance with the same context
+    return this.executeWorkflow(
+      instance.workflowId,
+      {
+        context: instance.context as Record<string, any>,
+        versionId: undefined,
+      },
+      creator,
+      temporalService,
+    );
+  }
+
+  async signalInstance(
+    instanceId: bigint,
+    dto: { signalName: string; payload: Record<string, any> },
+    temporalService: any,
+  ) {
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+    });
+
+    if (!instance) throw new NotFoundException('Instance not found');
+    if (!instance.temporalRunId) {
+      throw new Error('Instance has no Temporal run ID');
+    }
+
+    await temporalService.signalWorkflow(
+      instance.temporalRunId,
+      dto.signalName,
+      dto.payload,
+    );
+    return { success: true };
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { WorkflowEventOutboxController } from './workflowEventOutbox.controller';
+import { WorkflowEventOutboxService } from './workflowEventOutbox.service';
+
+describe('WorkflowEventOutboxController', () => {
+  let controller: WorkflowEventOutboxController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [WorkflowEventOutboxController],
+      providers: [WorkflowEventOutboxService],
+    }).compile();
+
+    controller = module.get<WorkflowEventOutboxController>(
+      WorkflowEventOutboxController,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

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

@@ -0,0 +1,147 @@
+import {
+  ACAttrFilter,
+  ACGuard,
+  ApiPaginatedResponse,
+  PageDto,
+  PageMetaDto,
+  PageOptionsDto,
+} from '@gadmin2n/nest-common';
+import {
+  Body,
+  Controller,
+  Delete,
+  Inject,
+  NotFoundException,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiCreatedResponse,
+  ApiNotFoundResponse,
+  ApiOkResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import { Prisma } from '@prisma/client';
+import { UseRoles } from 'nest-access-control';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { Logger } from 'winston';
+import {
+  EffectedCount,
+  UploudResponse,
+  WorkflowEventOutboxFindManyArgs,
+  WorkflowEventOutboxWhereSelect,
+} from '../../generated/workflowEventOutbox/dto/workflowEventOutbox-types.dto';
+import { WorkflowEventOutboxEntity } from '../../generated/workflowEventOutbox/entities/workflowEventOutbox.entity';
+import { WorkflowEventOutboxService } from './workflowEventOutbox.service';
+
+import { ConfigService } from '@nestjs/config';
+
+@UseGuards(ACGuard)
+@Controller('workflowEventOutbox')
+@ApiTags('workflowEventOutbox')
+export class WorkflowEventOutboxController {
+  constructor(
+    private readonly workflowEventOutboxService: WorkflowEventOutboxService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'workflowEventOutbox',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: WorkflowEventOutboxEntity })
+  async createOne() {
+    // 该资源为只读，创建接口已禁用
+    throw new NotFoundException();
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'workflowEventOutbox',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(WorkflowEventOutboxEntity)
+  async findMany(
+    @Body() body: WorkflowEventOutboxFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<WorkflowEventOutboxEntity>> {
+    const { itemCount, entities } =
+      await this.workflowEventOutboxService.findMany(
+        body as Prisma.WorkflowEventOutboxFindManyArgs,
+      );
+    const { skip = 0, take = 10 } =
+      body as Prisma.WorkflowEventOutboxFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map((item) => new WorkflowEventOutboxEntity(acAttrFilter(item))),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'workflowEventOutbox',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: WorkflowEventOutboxEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: WorkflowEventOutboxWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.workflowEventOutboxService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new WorkflowEventOutboxEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'workflowEventOutbox',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: WorkflowEventOutboxEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique() {
+    // 该资源为只读，更新接口已禁用
+    throw new NotFoundException();
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'workflowEventOutbox',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique() {
+    // 该资源为只读，删除接口已禁用
+    throw new NotFoundException();
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'workflowEventOutbox',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: UploudResponse })
+  async uploadFile() {
+    // 该资源为只读，上传接口已禁用
+    throw new NotFoundException();
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { WorkflowEventOutboxController } from './workflowEventOutbox.controller';
+import { WorkflowEventOutboxService } from './workflowEventOutbox.service';
+
+@Module({
+  controllers: [WorkflowEventOutboxController],
+  providers: [WorkflowEventOutboxService],
+  exports: [WorkflowEventOutboxService],
+})
+export class WorkflowEventOutboxModule {}