@gadmin2n/schematics 0.0.95 → 0.0.97

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

@@ -2,6 +2,7 @@ import {
   Body,
   Controller,
   Delete,
+  ForbiddenException,
   Get,
   Param,
   ParseIntPipe,
@@ -11,6 +12,7 @@ import {
   UseGuards,
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
+import { PrismaService } from 'nestjs-prisma';
 import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
 import {
   CreateCanvasDto,
@@ -24,13 +26,29 @@ import { CanvasService } from './canvas.service';
 @UseGuards(AuthGuard)
 @Controller('canvas')
 export class CanvasController {
-  constructor(private readonly canvasService: CanvasService) {}
+  constructor(
+    private readonly canvasService: CanvasService,
+    private readonly prisma: PrismaService,
+  ) {}
 
   @Get()
   findAll(@Req() req) {
     return this.canvasService.findAllByUser(req.user.userid);
   }
 
+  @Get('all')
+  async findAllForAdmin(@Req() req) {
+    const record = await this.prisma.user.findFirst({
+      where: { userid: req.user.userid },
+      select: { roles: true },
+    });
+    const roles: string[] = record ? JSON.parse(record.roles) : [];
+    if (!roles.includes('SYSTEM_ADMIN')) {
+      throw new ForbiddenException('仅 SYSTEM_ADMIN 可访问');
+    }
+    return this.canvasService.findAllCanvases();
+  }
+
   @Post()
   create(@Req() req, @Body() dto: CreateCanvasDto) {
     return this.canvasService.create(req.user.userid, dto);
@@ -56,12 +74,23 @@ export class CanvasController {
 
   @Get(':id')
   findOne(@Req() req, @Param('id') id: string) {
-    return this.canvasService.findOne(id, req.user.userid);
+    const roles: string[] = req.user?.configPerms?.roles ?? [];
+    const isAdmin = roles.includes('SYSTEM_ADMIN');
+    return this.canvasService.findOne(
+      id,
+      isAdmin ? undefined : req.user.userid,
+    );
   }
 
   @Put(':id')
   update(@Req() req, @Param('id') id: string, @Body() dto: UpdateCanvasDto) {
-    return this.canvasService.update(id, req.user.userid, dto);
+    const roles: string[] = req.user?.configPerms?.roles ?? [];
+    const isAdmin = roles.includes('SYSTEM_ADMIN');
+    return this.canvasService.update(
+      id,
+      isAdmin ? undefined : req.user.userid,
+      dto,
+    );
   }
 
   @Delete(':id')

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

@@ -25,9 +25,9 @@ export class CanvasService {
     });
   }
 
-  findOne(id: string, userId: string) {
+  findOne(id: string, userId?: string) {
     return this.prisma.canvas.findFirst({
-      where: { id, userId },
+      where: userId ? { id, userId } : { id },
     });
   }
 
@@ -58,10 +58,12 @@ export class CanvasService {
     });
   }
 
-  async update(id: string, userId: string, dto: UpdateCanvasDto) {
+  async update(id: string, userId: string | undefined, dto: UpdateCanvasDto) {
     if (dto.name !== undefined) {
       const existing = await this.prisma.canvas.findFirst({
-        where: { userId, name: dto.name, NOT: { id } },
+        where: userId
+          ? { userId, name: dto.name, NOT: { id } }
+          : { name: dto.name, NOT: { id } },
       });
       if (existing) {
         throw new ConflictException('Canvas 名称已存在');
@@ -71,7 +73,7 @@ export class CanvasService {
     // 如果改名且已发布，同步更新 page 表的所有名称字段 + code + path
     if (dto.name !== undefined) {
       const canvas = await this.prisma.canvas.findFirst({
-        where: { id, userId },
+        where: userId ? { id, userId } : { id },
       });
       if (canvas?.publishedPageCode) {
         const newSlug =
@@ -100,7 +102,7 @@ export class CanvasService {
     }
 
     return this.prisma.canvas.updateMany({
-      where: { id, userId },
+      where: userId ? { id, userId } : { id },
       data: {
         ...(dto.name !== undefined && { name: dto.name }),
         ...(dto.items !== undefined && { items: dto.items }),
@@ -228,6 +230,26 @@ export class CanvasService {
     return { success: true };
   }
 
+  async findAllCanvases() {
+    const canvases = await this.prisma.canvas.findMany({
+      orderBy: { createdAt: 'asc' },
+    });
+
+    const userIds = [...new Set(canvases.map((c) => c.userId))];
+    const users = await this.prisma.user.findMany({
+      where: { userid: { in: userIds } },
+      select: { userid: true, username: true },
+    });
+    const userMap = new Map(
+      users.map((u) => [u.userid, u.username ?? u.userid]),
+    );
+
+    return canvases.map((c) => ({
+      ...c,
+      ownerName: userMap.get(c.userId) ?? c.userId,
+    }));
+  }
+
   async savedQueryCreate(dto: CreateSavedQueryDto) {
     const sql = dto.sql.trim();
     if (!sql.toUpperCase().startsWith('SELECT')) {

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

@@ -0,0 +1,220 @@
+import {
+  validateDslHandles,
+  type NodeOutputsMap,
+  type WorkflowDsl,
+} from './workflow-dsl-validate';
+
+// Test fixture: a small NodeOutputsMap mirroring the live DB seed for the
+// node types we exercise here. Mirrors NODE_TYPE_META used in the worker test.
+const OUTPUTS_MAP: NodeOutputsMap = {
+  if_else: ['true', 'false'],
+  switch: null,
+  cron_trigger: [],
+  manual_trigger: [],
+  webhook_trigger: [],
+  http_request: [],
+};
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function makeNode(
+  id: string,
+  type: string,
+  config: Record<string, any> = {},
+): WorkflowDsl['nodes'][number] {
+  return { id, type, config };
+}
+
+function makeEdge(
+  id: string,
+  source: string,
+  target: string,
+  sourceHandle?: string,
+): WorkflowDsl['edges'][number] {
+  return sourceHandle === undefined
+    ? { id, source, target }
+    : { id, source, target, sourceHandle };
+}
+
+// ─── if_else (enumerated outputs) ────────────────────────────────────────────
+
+describe('validateDslHandles — if_else', () => {
+  it('accepts sourceHandle "true"', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', 'true')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('accepts sourceHandle "false"', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', 'false')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('rejects unknown sourceHandle "maybe"', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', 'maybe')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
+    expect(errors[0].reason).toMatch(/not in declared outputs/);
+  });
+
+  it('rejects missing sourceHandle', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('MISSING_HANDLE');
+    expect(errors[0].reason).toMatch(/requires a sourceHandle/);
+  });
+
+  it('rejects empty-string sourceHandle as missing', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', '')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('MISSING_HANDLE');
+  });
+});
+
+// ─── cron_trigger (no named outputs) ─────────────────────────────────────────
+
+describe('validateDslHandles — cron_trigger (no named outputs)', () => {
+  it('rejects sourceHandle "foo" on a node with no named handles', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
+      edges: [makeEdge('e1', 't', 'a', 'foo')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('EXTRA_HANDLE');
+    expect(errors[0].reason).toMatch(/no named output handles/);
+  });
+
+  it('accepts no sourceHandle', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
+      edges: [makeEdge('e1', 't', 'a')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('accepts empty-string sourceHandle (treated as absent for [] nodes)', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
+      edges: [makeEdge('e1', 't', 'a', '')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+});
+
+// ─── switch (dynamic outputs) ────────────────────────────────────────────────
+
+describe('validateDslHandles — switch (dynamic outputs)', () => {
+  it('accepts sourceHandle matching a case value', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('s', 'switch', { cases: [{ value: 'a' }, { value: 'b' }] }),
+        makeNode('x', 'http_request'),
+      ],
+      edges: [makeEdge('e1', 's', 'x', 'a')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('rejects sourceHandle not in case values', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('s', 'switch', { cases: [{ value: 'a' }] }),
+        makeNode('x', 'http_request'),
+      ],
+      edges: [makeEdge('e1', 's', 'x', 'c')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
+  });
+
+  it('skips validation when switch config has no cases (in-progress editor)', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('s', 'switch'), makeNode('x', 'http_request')],
+      edges: [makeEdge('e1', 's', 'x', 'anything')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+});
+
+// ─── out-of-scope (orphan / unknown) ────────────────────────────────────────
+
+describe('validateDslHandles — out-of-scope', () => {
+  it('ignores edge referencing missing source node', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'ghost', 'b', 'true')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('ignores edges from unknown node types', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('u', 'wholly_made_up_type'),
+        makeNode('b', 'http_request'),
+      ],
+      edges: [makeEdge('e1', 'u', 'b', 'whatever')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+});
+
+// ─── multiple errors collected ──────────────────────────────────────────────
+
+describe('validateDslHandles — multiple errors', () => {
+  it('collects every error in one pass', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('if', 'if_else'),
+        makeNode('cron', 'cron_trigger'),
+        makeNode('sw', 'switch', { cases: [{ value: 'a' }] }),
+        makeNode('x', 'http_request'),
+      ],
+      edges: [
+        makeEdge('e1', 'if', 'x', 'maybe'), // bad enumerated
+        makeEdge('e2', 'if', 'x'), // missing required
+        makeEdge('e3', 'cron', 'x', 'foo'), // forbidden handle
+        makeEdge('e4', 'sw', 'x', 'c'), // bad dynamic
+      ],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(4);
+    expect(errors.map((e) => e.edgeId).sort()).toEqual([
+      'e1',
+      'e2',
+      'e3',
+      'e4',
+    ]);
+    const byEdge = Object.fromEntries(errors.map((e) => [e.edgeId, e.code]));
+    expect(byEdge).toEqual({
+      e1: 'UNKNOWN_HANDLE',
+      e2: 'MISSING_HANDLE',
+      e3: 'EXTRA_HANDLE',
+      e4: 'UNKNOWN_HANDLE',
+    });
+  });
+});

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

@@ -0,0 +1,129 @@
+/**
+ * DSL handle validator (server-side).
+ *
+ * Mirrors temporal/worker/src/dsl/validate.ts but is independent:
+ * - reads node-type outputs from a passed-in map (caller fetches from DB)
+ * - returns the same DslValidationCode discriminator for FE compatibility
+ *
+ * Why duplicated rather than imported from worker: server and worker are
+ * separate projects without a shared package; cross-project imports would
+ * break tsc paths and Docker build.
+ */
+
+export type DslValidationCode =
+  | 'EXTRA_HANDLE' // node has [] outputs, but edge set sourceHandle
+  | 'MISSING_HANDLE' // node has named outputs, but edge has no sourceHandle (or empty string)
+  | 'UNKNOWN_HANDLE'; // edge sourceHandle is set but ∉ declared outputs
+
+export interface DslValidationError {
+  edgeId: string;
+  source: string;
+  target: string;
+  code: DslValidationCode;
+  reason: string;
+}
+
+export interface DslNode {
+  id: string;
+  type: string;
+  config?: Record<string, any>;
+}
+
+export interface DslEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string;
+}
+
+export interface WorkflowDsl {
+  nodes: DslNode[];
+  edges: DslEdge[];
+}
+
+/**
+ * Map from node type name -> outputs declaration.
+ *
+ *  - null:        dynamic (e.g. switch — derived from node.config)
+ *  - []:          single anonymous output, no sourceHandle allowed
+ *  - ['a','b',…]: enumerated named outputs; sourceHandle MUST be one of them
+ *  - undefined:   unknown type; validator skips edges from such nodes
+ */
+export type NodeOutputsMap = Record<string, string[] | null>;
+
+/**
+ * Validate every edge's sourceHandle against the source node's outputs metadata.
+ * Returns an array of errors (empty if DSL is valid).
+ */
+export function validateDslHandles(
+  dsl: WorkflowDsl,
+  outputsMap: NodeOutputsMap,
+): DslValidationError[] {
+  const errors: DslValidationError[] = [];
+  const nodeMap = new Map<string, DslNode>(dsl.nodes.map((n) => [n.id, n]));
+
+  for (const edge of dsl.edges) {
+    const src = nodeMap.get(edge.source);
+    if (!src) continue; // separate concern: orphan edge — not this validator's job
+    if (!(src.type in outputsMap)) continue; // unknown node type — out of scope
+
+    const declared = outputsMap[src.type];
+    const handles =
+      declared === null ? deriveDynamicOutputs(src) : declared;
+
+    // Empty named-handle list AND declared-non-null => no sourceHandle allowed
+    if (declared !== null && handles.length === 0) {
+      if (edge.sourceHandle != null && edge.sourceHandle !== '') {
+        errors.push({
+          edgeId: edge.id,
+          source: edge.source,
+          target: edge.target,
+          code: 'EXTRA_HANDLE',
+          reason: `Node "${src.type}" has no named output handles; edge must not set sourceHandle (got "${edge.sourceHandle}").`,
+        });
+      }
+      continue;
+    }
+
+    // Dynamic + still-empty (e.g. switch with no cases): in-progress, skip
+    if (handles.length === 0) continue;
+
+    if (edge.sourceHandle == null || edge.sourceHandle === '') {
+      errors.push({
+        edgeId: edge.id,
+        source: edge.source,
+        target: edge.target,
+        code: 'MISSING_HANDLE',
+        reason: `Node "${src.type}" requires a sourceHandle; choose one of: ${handles.join(', ')}.`,
+      });
+      continue;
+    }
+
+    if (!handles.includes(edge.sourceHandle)) {
+      errors.push({
+        edgeId: edge.id,
+        source: edge.source,
+        target: edge.target,
+        code: 'UNKNOWN_HANDLE',
+        reason: `Node "${src.type}" sourceHandle "${edge.sourceHandle}" is not in declared outputs: ${handles.join(', ')}.`,
+      });
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * For dynamic-output nodes (currently just `switch`), derive the list of
+ * handle ids from the node's config.
+ */
+function deriveDynamicOutputs(node: DslNode): string[] {
+  if (node.type === 'switch') {
+    const cases = node.config?.cases as Array<{ value?: string }> | undefined;
+    if (!Array.isArray(cases)) return [];
+    return cases
+      .map((c) => c?.value)
+      .filter((v): v is string => typeof v === 'string' && v.length > 0);
+  }
+  return [];
+}

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

@@ -33,6 +33,7 @@ export interface ExportPayload {
     configSchema: any;
     inputSchema: any;
     outputSchema: any;
+    outputs: any;
     isBuiltin: boolean;
   }>;
 }

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

@@ -129,6 +129,7 @@ export class WorkflowExportService {
         configSchema: nt.configSchema as any,
         inputSchema: nt.inputSchema as any,
         outputSchema: nt.outputSchema as any,
+        outputs: nt.outputs as any,
         isBuiltin: nt.isBuiltin,
       })),
     };
@@ -193,6 +194,7 @@ export class WorkflowExportService {
             configSchema: nt.configSchema as any,
             inputSchema: nt.inputSchema as any,
             outputSchema: nt.outputSchema as any,
+            outputs: nt.outputs as any,
             isBuiltin: nt.isBuiltin,
           })),
         }
@@ -224,6 +226,7 @@ export class WorkflowExportService {
             configSchema: nt.configSchema,
             inputSchema: nt.inputSchema,
             outputSchema: nt.outputSchema,
+            outputs: nt.outputs,
             isBuiltin: nt.isBuiltin,
             creator,
           },
@@ -235,6 +238,7 @@ export class WorkflowExportService {
             configSchema: nt.configSchema,
             inputSchema: nt.inputSchema,
             outputSchema: nt.outputSchema,
+            outputs: nt.outputs,
           },
         });
       }

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

@@ -22,6 +22,16 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         findFirst: jest.fn(),
         create: jest.fn(),
       },
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          { type: 'cron_trigger', outputs: [] },
+          { type: 'manual_trigger', outputs: [] },
+          { type: 'webhook_trigger', outputs: [] },
+          { type: 'http_request', outputs: [] },
+          { type: 'if_else', outputs: ['true', 'false'] },
+          { type: 'switch', outputs: null },
+        ]),
+      },
       $transaction: jest.fn(async (cb: any) =>
         cb({
           workflowVersion: {
@@ -197,6 +207,42 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         service.publish(ID, { changeSummary: 'init' }, 'tester'),
       ).resolves.toBeDefined();
     });
+
+    it('rejects with 400 BadRequestException when DSL has invalid sourceHandle', async () => {
+      // if_else node has enumerated outputs ['true','false']; sending 'maybe'
+      // must trigger the new sourceHandle validator and produce a 400 with a
+      // structured error payload the frontend can use to highlight bad edges.
+      const dsl = {
+        nodes: [
+          { id: 't1', type: 'manual_trigger', config: {} },
+          { id: 'if1', type: 'if_else', config: {} },
+          { id: 'h1', type: 'http_request', config: {} },
+        ],
+        edges: [
+          { id: 'e1', source: 't1', target: 'if1' },
+          { id: 'e2', source: 'if1', target: 'h1', sourceHandle: 'maybe' },
+        ],
+      };
+      prisma.workflow.findUnique.mockResolvedValueOnce(mkWorkflow(dsl));
+
+      await expect(
+        service.publish(ID, { changeSummary: 'init' }, 'tester'),
+      ).rejects.toMatchObject({
+        status: 400,
+        response: expect.objectContaining({
+          code: 'DSL_HANDLE_VALIDATION',
+          errors: expect.arrayContaining([
+            expect.objectContaining({
+              edgeId: 'e2',
+              code: 'UNKNOWN_HANDLE',
+            }),
+          ]),
+        }),
+      });
+
+      // Status flip must NOT have happened
+      expect(prisma.workflow.update).not.toHaveBeenCalled();
+    });
   });
 
   describe('toggleEnabled', () => {

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

@@ -10,6 +10,10 @@ import { PrismaService } from 'nestjs-prisma';
 import { validateDslGraph } from './dsl-validate.util';
 import { TemporalService } from './temporal.service';
 import { verifyWebhookSignature } from './webhook-signature.util';
+import {
+  validateDslHandles,
+  type NodeOutputsMap,
+} from './workflow-dsl-validate';
 
 @Injectable()
 export class WorkflowService {
@@ -285,6 +289,29 @@ export class WorkflowService {
       throw new BadRequestException(`Invalid DSL: ${err?.message ?? err}`);
     }
 
+    // Per-edge sourceHandle validation against node-type outputs declared in the
+    // database (t_workflow_node_type.outputs). Hard-fail with a structured error
+    // list so the frontend can highlight invalid edges.
+    const nodeTypes = await this.prisma.workflowNodeType.findMany({
+      select: { type: true, outputs: true },
+    });
+    const outputsMap: NodeOutputsMap = {};
+    for (const nt of nodeTypes) {
+      // Pass through: null = dynamic, [] = single anonymous, [..] = enumerated
+      outputsMap[nt.type] =
+        nt.outputs === undefined
+          ? []
+          : (nt.outputs as unknown as string[] | null);
+    }
+    const handleErrors = validateDslHandles(dslToPublish as any, outputsMap);
+    if (handleErrors.length > 0) {
+      throw new BadRequestException({
+        message: 'DSL validation failed: invalid edge sourceHandle(s)',
+        code: 'DSL_HANDLE_VALIDATION',
+        errors: handleErrors,
+      });
+    }
+
     // Validate webhook path collisions across other published workflows
     const webhookConfigs = this.extractWebhookConfigs(dslToPublish);
     if (webhookConfigs.length > 0) {

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

@@ -78,6 +78,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -103,6 +104,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -128,6 +130,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -139,6 +142,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -230,6 +234,7 @@ describe('WorkflowNodeTypeService', () => {
         configSchema: {},
         inputSchema: {},
         outputSchema: {},
+        outputs: [],
         description: 'test_description',
         isBuiltin: true,
       } as any;
@@ -259,6 +264,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },