@gadmin2n/schematics 0.0.71 → 0.0.74

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

@@ -0,0 +1,100 @@
+import {
+  Injectable,
+  Logger,
+  OnModuleDestroy,
+  OnModuleInit,
+} from '@nestjs/common';
+import { Client, Connection } from '@temporalio/client';
+
+const TEMPORAL_ADDRESS = process.env.TEMPORAL_ADDRESS || 'localhost:7233';
+const TEMPORAL_NAMESPACE = process.env.TEMPORAL_NAMESPACE || 'default';
+const TASK_QUEUE = process.env.TEMPORAL_TASK_QUEUE || 'workflow-execution';
+
+@Injectable()
+export class TemporalService implements OnModuleInit, OnModuleDestroy {
+  private connection: Connection;
+  private client: Client;
+  private readonly logger = new Logger(TemporalService.name);
+
+  async onModuleInit() {
+    try {
+      this.connection = await Connection.connect({ address: TEMPORAL_ADDRESS });
+      this.client = new Client({
+        connection: this.connection,
+        namespace: TEMPORAL_NAMESPACE,
+      });
+      this.logger.log(`Connected to Temporal at ${TEMPORAL_ADDRESS}`);
+    } catch (err) {
+      this.logger.warn(
+        `Failed to connect to Temporal at ${TEMPORAL_ADDRESS}: ${err.message}. Workflow execution will be unavailable.`,
+      );
+    }
+  }
+
+  async onModuleDestroy() {
+    await this.connection?.close();
+  }
+
+  /**
+   * Start a workflow execution via Temporal.
+   */
+  async startWorkflow(params: {
+    instanceId: number;
+    workflowId: number;
+    versionId: number;
+    dsl: any;
+    context: Record<string, any>;
+  }): Promise<{ temporalRunId: string }> {
+    if (!this.client) {
+      throw new Error('Temporal client not connected');
+    }
+
+    const workflowId = `wf-${params.workflowId}-${params.instanceId}`;
+
+    const handle = await this.client.workflow.start('dslWorkflow', {
+      taskQueue: TASK_QUEUE,
+      workflowId,
+      args: [params],
+    });
+
+    return { temporalRunId: handle.workflowId };
+  }
+
+  /**
+   * Cancel a running workflow.
+   */
+  async cancelWorkflow(temporalRunId: string): Promise<void> {
+    if (!this.client) throw new Error('Temporal client not connected');
+    const handle = this.client.workflow.getHandle(temporalRunId);
+    await handle.cancel();
+  }
+
+  /**
+   * Send a signal to a running workflow (e.g., approval).
+   */
+  async signalWorkflow(
+    temporalRunId: string,
+    signalName: string,
+    payload: any,
+  ): Promise<void> {
+    if (!this.client) throw new Error('Temporal client not connected');
+    const handle = this.client.workflow.getHandle(temporalRunId);
+    await handle.signal(signalName, payload);
+  }
+
+  /**
+   * Query a workflow for its current progress.
+   */
+  async queryWorkflow(temporalRunId: string, queryName: string): Promise<any> {
+    if (!this.client) throw new Error('Temporal client not connected');
+    const handle = this.client.workflow.getHandle(temporalRunId);
+    return await handle.query(queryName);
+  }
+
+  /**
+   * Check if Temporal client is available.
+   */
+  isAvailable(): boolean {
+    return !!this.client;
+  }
+}

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

@@ -0,0 +1,19 @@
+import { IsInt, IsObject, IsOptional, IsString } from 'class-validator';
+
+export class ExecuteWorkflowDto {
+  @IsOptional()
+  @IsObject()
+  context?: Record<string, any>;
+
+  @IsOptional()
+  @IsInt()
+  versionId?: number;
+}
+
+export class SignalWorkflowDto {
+  @IsString()
+  signalName: string;
+
+  @IsObject()
+  payload: Record<string, any>;
+}

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

@@ -0,0 +1,43 @@
+import { IsObject } from 'class-validator';
+
+export class ImportPayloadDto {
+  @IsObject()
+  payload: ExportPayload;
+}
+
+export interface ExportPayload {
+  version: number;
+  exportedAt: string;
+  workflow: {
+    code: string;
+    name: string;
+    description: string | null;
+    status: string;
+    dsl: any;
+  };
+  nodeInstances: Array<{
+    sourceId: string;
+    code: string;
+    name: string;
+    description: string | null;
+    nodeTypeKey: string;
+    config: any;
+    isEnabled: boolean;
+  }>;
+  nodeTypes: Array<{
+    type: string;
+    category: string;
+    label: string;
+    icon: string;
+    description: string | null;
+    configSchema: any;
+    inputSchema: any;
+    outputSchema: any;
+    isBuiltin: boolean;
+  }>;
+}
+
+export interface ImportPreviewResponse {
+  current: Partial<ExportPayload> | null;
+  incoming: ExportPayload;
+}

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

@@ -0,0 +1,317 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { PrismaService } from 'nestjs-prisma';
+import { ExportPayload, ImportPreviewResponse } from './workflow-export.dto';
+
+const EXPORT_TOKEN_SECRET =
+  process.env.TAIHU_ODC_APP_TOKEN || 'gadmin-default-secret';
+const EXPORT_TOKEN_EXPIRY = 30 * 60; // 30 minutes in seconds
+
+interface ExportTokenPayload {
+  workflowCode: string;
+}
+
+@Injectable()
+export class WorkflowExportService {
+  constructor(private prisma: PrismaService) {}
+
+  /** Generate a JWT export token for a workflow */
+  async generateExportToken(
+    workflowId: bigint,
+    baseUrl: string,
+  ): Promise<{ url: string }> {
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { id: workflowId },
+      select: { code: true },
+    });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+
+    const token = jwt.sign(
+      { workflowCode: workflow.code } as ExportTokenPayload,
+      EXPORT_TOKEN_SECRET,
+      { expiresIn: EXPORT_TOKEN_EXPIRY },
+    );
+
+    const url = `${baseUrl}/workflow/export/${workflow.code}?token=${token}`;
+    return { url };
+  }
+
+  /** Verify export token and return the full export payload */
+  async getExportPayload(code: string, token: string): Promise<ExportPayload> {
+    let decoded: ExportTokenPayload;
+    try {
+      decoded = jwt.verify(token, EXPORT_TOKEN_SECRET) as ExportTokenPayload;
+    } catch {
+      throw new UnauthorizedException('Export token is invalid or expired');
+    }
+
+    if (decoded.workflowCode !== code) {
+      throw new UnauthorizedException('Token does not match this workflow');
+    }
+
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { code },
+      include: { versions: { orderBy: { version: 'desc' }, take: 1 } },
+    });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+
+    // Use latest published version DSL, fallback to draft DSL
+    const dsl = (workflow.versions[0]?.dsl ?? workflow.dsl) as any;
+
+    // Collect referenced NodeInstance IDs from DSL
+    const instanceIds = new Set<bigint>();
+    if (dsl?.nodes) {
+      for (const node of dsl.nodes) {
+        if (node.instanceRef?.instanceId) {
+          instanceIds.add(BigInt(node.instanceRef.instanceId));
+        }
+      }
+    }
+
+    // Fetch referenced NodeInstances
+    const nodeInstances =
+      instanceIds.size > 0
+        ? await this.prisma.workflowNodeInstance.findMany({
+            where: { id: { in: Array.from(instanceIds) } },
+            include: { nodeType: true },
+          })
+        : [];
+
+    // Collect NodeType keys from instances + DSL nodes
+    const nodeTypeKeys = new Set<string>();
+    for (const ni of nodeInstances) {
+      nodeTypeKeys.add(ni.nodeType.type);
+    }
+    if (dsl?.nodes) {
+      for (const node of dsl.nodes) {
+        if (node.type) nodeTypeKeys.add(node.type);
+      }
+    }
+
+    // Fetch NodeTypes
+    const nodeTypes =
+      nodeTypeKeys.size > 0
+        ? await this.prisma.workflowNodeType.findMany({
+            where: { type: { in: Array.from(nodeTypeKeys) } },
+          })
+        : [];
+
+    return {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      workflow: {
+        code: workflow.code,
+        name: workflow.name,
+        description: workflow.description,
+        status: workflow.status,
+        dsl,
+      },
+      nodeInstances: nodeInstances.map((ni) => ({
+        sourceId: String(ni.id),
+        code: ni.code,
+        name: ni.name,
+        description: ni.description,
+        nodeTypeKey: ni.nodeType.type,
+        config: ni.config,
+        isEnabled: ni.isEnabled,
+      })),
+      nodeTypes: nodeTypes.map((nt) => ({
+        type: nt.type,
+        category: nt.category,
+        label: nt.label,
+        icon: nt.icon,
+        description: nt.description,
+        configSchema: nt.configSchema as any,
+        inputSchema: nt.inputSchema as any,
+        outputSchema: nt.outputSchema as any,
+        isBuiltin: nt.isBuiltin,
+      })),
+    };
+  }
+
+  /** Preview import — return current state vs incoming for diff */
+  async importPreview(payload: ExportPayload): Promise<ImportPreviewResponse> {
+    if (!payload?.workflow?.code) {
+      throw new BadRequestException('Invalid payload: missing workflow code');
+    }
+
+    // Look up current state by code
+    const existingWorkflow = await this.prisma.workflow.findUnique({
+      where: { code: payload.workflow.code },
+      include: { versions: { orderBy: { version: 'desc' }, take: 1 } },
+    });
+
+    // Look up existing node instances by code
+    const incomingCodes = payload.nodeInstances.map((ni) => ni.code);
+    const existingInstances =
+      incomingCodes.length > 0
+        ? await this.prisma.workflowNodeInstance.findMany({
+            where: { code: { in: incomingCodes } },
+            include: { nodeType: true },
+          })
+        : [];
+
+    // Look up existing node types by type key
+    const incomingTypes = payload.nodeTypes.map((nt) => nt.type);
+    const existingTypes =
+      incomingTypes.length > 0
+        ? await this.prisma.workflowNodeType.findMany({
+            where: { type: { in: incomingTypes } },
+          })
+        : [];
+
+    const current: Partial<ExportPayload> | null = existingWorkflow
+      ? {
+          workflow: {
+            code: existingWorkflow.code,
+            name: existingWorkflow.name,
+            description: existingWorkflow.description,
+            status: existingWorkflow.status,
+            dsl: (existingWorkflow.versions[0]?.dsl ??
+              existingWorkflow.dsl) as any,
+          },
+          nodeInstances: existingInstances.map((ni) => ({
+            sourceId: String(ni.id),
+            code: ni.code,
+            name: ni.name,
+            description: ni.description,
+            nodeTypeKey: ni.nodeType.type,
+            config: ni.config as any,
+            isEnabled: ni.isEnabled,
+          })),
+          nodeTypes: existingTypes.map((nt) => ({
+            type: nt.type,
+            category: nt.category,
+            label: nt.label,
+            icon: nt.icon,
+            description: nt.description,
+            configSchema: nt.configSchema as any,
+            inputSchema: nt.inputSchema as any,
+            outputSchema: nt.outputSchema as any,
+            isBuiltin: nt.isBuiltin,
+          })),
+        }
+      : null;
+
+    return { current, incoming: payload };
+  }
+
+  /** Confirm import — execute upsert with DSL remapping in a transaction */
+  async importConfirm(
+    payload: ExportPayload,
+    creator: string,
+  ): Promise<{ success: boolean; workflowId: string; workflowName: string }> {
+    if (!payload?.workflow?.code) {
+      throw new BadRequestException('Invalid payload: missing workflow code');
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      // 1. Upsert NodeTypes by `type`
+      for (const nt of payload.nodeTypes) {
+        await tx.workflowNodeType.upsert({
+          where: { type: nt.type },
+          create: {
+            type: nt.type,
+            category: nt.category as any,
+            label: nt.label,
+            icon: nt.icon,
+            description: nt.description,
+            configSchema: nt.configSchema,
+            inputSchema: nt.inputSchema,
+            outputSchema: nt.outputSchema,
+            isBuiltin: nt.isBuiltin,
+            creator,
+          },
+          update: {
+            category: nt.category as any,
+            label: nt.label,
+            icon: nt.icon,
+            description: nt.description,
+            configSchema: nt.configSchema,
+            inputSchema: nt.inputSchema,
+            outputSchema: nt.outputSchema,
+          },
+        });
+      }
+
+      // 2. Upsert NodeInstances by `code`, build sourceId → newId map
+      const idMap = new Map<string, string>();
+
+      for (const ni of payload.nodeInstances) {
+        const nodeType = await tx.workflowNodeType.findUnique({
+          where: { type: ni.nodeTypeKey },
+        });
+        if (!nodeType) {
+          throw new BadRequestException(
+            `NodeType "${ni.nodeTypeKey}" not found after upsert`,
+          );
+        }
+
+        const record = await tx.workflowNodeInstance.upsert({
+          where: { code: ni.code },
+          create: {
+            code: ni.code,
+            nodeTypeId: nodeType.id,
+            name: ni.name,
+            description: ni.description,
+            config: ni.config,
+            isEnabled: ni.isEnabled,
+            creator,
+          },
+          update: {
+            nodeTypeId: nodeType.id,
+            name: ni.name,
+            description: ni.description,
+            config: ni.config,
+            isEnabled: ni.isEnabled,
+          },
+        });
+
+        idMap.set(ni.sourceId, String(record.id));
+      }
+
+      // 3. Remap DSL instanceRef.instanceId
+      const dsl = JSON.parse(JSON.stringify(payload.workflow.dsl));
+      if (dsl?.nodes) {
+        for (const node of dsl.nodes) {
+          if (node.instanceRef?.instanceId) {
+            const newId = idMap.get(node.instanceRef.instanceId);
+            if (newId) {
+              node.instanceRef.instanceId = newId;
+            }
+          }
+        }
+      }
+
+      // 4. Upsert Workflow by `code`, always set to DRAFT
+      const workflow = await tx.workflow.upsert({
+        where: { code: payload.workflow.code },
+        create: {
+          code: payload.workflow.code,
+          name: payload.workflow.name,
+          description: payload.workflow.description,
+          status: 'DRAFT',
+          dsl,
+          creator,
+        },
+        update: {
+          name: payload.workflow.name,
+          description: payload.workflow.description,
+          status: 'DRAFT',
+          dsl,
+        },
+      });
+
+      return {
+        success: true,
+        workflowId: String(workflow.id),
+        workflowName: workflow.name,
+      };
+    });
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import AuthGuard from '../../lib/auth.guard';
+import { WorkflowNodeTypeService } from './workflow-node-type.service';
+
+@ApiTags('workflow-node-types')
+@UseGuards(AuthGuard)
+@Controller('workflow-node-types')
+export class WorkflowNodeTypeController {
+  constructor(private readonly service: WorkflowNodeTypeService) {}
+
+  @Get()
+  findAll() {
+    return this.service.findAll();
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from 'nestjs-prisma';
+
+@Injectable()
+export class WorkflowNodeTypeService {
+  constructor(private prisma: PrismaService) {}
+
+  findAll() {
+    return this.prisma.workflowNodeType.findMany({
+      orderBy: [{ category: 'asc' }, { type: 'asc' }],
+    });
+  }
+}