@gadmin2n/schematics 0.0.142 → 0.0.144

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

@@ -2,6 +2,7 @@
 import { ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { RuntimeConnectivityProbeService } from './runtime-connectivity-probe.service';
 import { TemporalTenantConfigController } from './temporalTenantConfig.controller';
 import { TemporalTenantConfigService } from './temporalTenantConfig.service';
 
@@ -18,6 +19,10 @@ const mockConfigService = {
   get: jest.fn(),
 };
 
+const mockProbes = {
+  create: jest.fn().mockReturnValue('signed-probe'),
+};
+
 // Mock Logger
 const mockLogger = {
   child: jest.fn().mockReturnThis(),
@@ -42,6 +47,7 @@ describe('TemporalTenantConfigController', () => {
           useValue: mockTemporalTenantConfigService,
         },
         { provide: ConfigService, useValue: mockConfigService },
+        { provide: RuntimeConnectivityProbeService, useValue: mockProbes },
         { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
       ],
     })
@@ -63,6 +69,41 @@ describe('TemporalTenantConfigController', () => {
     expect(controller).toBeDefined();
   });
 
+  it('tests the current connection values without persisting them', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: jest.fn().mockResolvedValue({
+        ok: true,
+        checks: [{ key: 'database', ok: true }],
+      }),
+    });
+
+    const result = await controller.testConnection({
+      adminUrl: 'http://temporal.example:8081/',
+      adminToken: 'admin-token',
+      namespace: 'gadmin-test',
+      dbUrl: 'postgresql://user:pass@gadmin-db:5432/gadmin_demo',
+      displayName: 'Gadmin Test',
+      runtimeBaseUrl: 'http://gadmin-server:8000/api',
+      runtimeToken: '0123456789abcdef0123456789abcdef',
+    } as any);
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://temporal.example:8081/admin/test-connection',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({
+          dbUrl: 'postgresql://user:pass@gadmin-db:5432/gadmin_demo',
+          runtimeBaseUrl: 'http://gadmin-server:8000/api',
+          runtimeProbeToken: 'signed-probe',
+        }),
+      }),
+    );
+    expect(result).toMatchObject({ ok: true });
+    expect(mockTemporalTenantConfigService.createOne).not.toHaveBeenCalled();
+    expect(mockTemporalTenantConfigService.updateUnique).not.toHaveBeenCalled();
+  });
+
   it('registers and persists the tenant runtime connection', async () => {
     global.fetch = jest.fn().mockResolvedValue({
       ok: true,

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

@@ -10,6 +10,7 @@ import {
   UserType,
 } from '@gadmin2n/nest-common';
 import {
+  BadGatewayException,
   BadRequestException,
   Body,
   Controller,
@@ -44,6 +45,7 @@ import {
 } from '../../generated/temporalTenantConfig/dto/temporalTenantConfig-types.dto';
 import { UpdateTemporalTenantConfigDto } from '../../generated/temporalTenantConfig/dto/update-temporalTenantConfig.dto';
 import { TemporalTenantConfigEntity } from '../../generated/temporalTenantConfig/entities/temporalTenantConfig.entity';
+import { RuntimeConnectivityProbeService } from './runtime-connectivity-probe.service';
 import { TemporalTenantConfigService } from './temporalTenantConfig.service';
 
 import { ConfigService } from '@nestjs/config';
@@ -55,10 +57,54 @@ import { FileInterceptor } from '@nestjs/platform-express';
 export class TemporalTenantConfigController {
   constructor(
     private readonly temporalTenantConfigService: TemporalTenantConfigService,
+    private readonly probes: RuntimeConnectivityProbeService,
     private readonly config: ConfigService,
     @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
   ) {}
 
+  @Post('testConnection')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'create',
+    possession: 'any',
+  })
+  async testConnection(@Body() body: CreateTemporalTenantConfigDto) {
+    assertRuntimeToken(body.runtimeToken);
+    let response: Response;
+    const adminUrl = body.adminUrl.replace(/\/+$/, '');
+
+    try {
+      response = await fetch(`${adminUrl}/admin/test-connection`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Admin-Token': body.adminToken,
+        },
+        body: JSON.stringify({
+          dbUrl: body.dbUrl,
+          runtimeBaseUrl: body.runtimeBaseUrl,
+          runtimeProbeToken: this.probes.create(),
+        }),
+        signal: AbortSignal.timeout(15_000),
+      });
+    } catch (error: any) {
+      throw new BadGatewayException(
+        `无法连接 Temporal 管理 API: ${String(error?.message ?? error)}`,
+      );
+    }
+
+    const result = await response.json().catch(async () => ({
+      error: await response.text().catch(() => ''),
+    }));
+    if (!response.ok) {
+      throw new BadGatewayException({
+        message: `Temporal 管理 API 连通性测试失败 (${response.status})`,
+        detail: result,
+      });
+    }
+    return result;
+  }
+
   @Post('createOne')
   @UseRoles({
     resource: 'temporalTenantConfig',
@@ -71,6 +117,7 @@ export class TemporalTenantConfigController {
     @ACAttrFilter() acAttrFilter,
     @Req() request: Request & { user: UserType },
   ) {
+    assertRuntimeToken(body.runtimeToken);
     body.creator = request.user.username;
 
     // 先调 shared temporal admin API（原子：失败则不写 DB）
@@ -163,6 +210,7 @@ export class TemporalTenantConfigController {
     @Body() body: UpdateTemporalTenantConfigDto,
     @ACAttrFilter() acAttrFilter,
   ) {
+    if (body.runtimeToken !== undefined) assertRuntimeToken(body.runtimeToken);
     const existing = await this.temporalTenantConfigService.findUnique(id, {
       adminUrl: true,
       adminToken: true,
@@ -247,3 +295,8 @@ export class TemporalTenantConfigController {
     };
   }
 }
+
+function assertRuntimeToken(value: string | undefined): void {
+  if (!value || value.length < 32)
+    throw new BadRequestException('Runtime Token 至少需要 32 个字符');
+}

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

@@ -1,10 +1,15 @@
 import { Module } from '@nestjs/common';
+import { RuntimeConnectivityProbeService } from './runtime-connectivity-probe.service';
 import { TemporalTenantConfigController } from './temporalTenantConfig.controller';
 import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+import { WorkflowRuntimeHealthController } from './workflow-runtime-health.controller';
 
 @Module({
-  controllers: [TemporalTenantConfigController],
-  providers: [TemporalTenantConfigService],
+  controllers: [
+    TemporalTenantConfigController,
+    WorkflowRuntimeHealthController,
+  ],
+  providers: [TemporalTenantConfigService, RuntimeConnectivityProbeService],
   exports: [TemporalTenantConfigService],
 })
 export class TemporalTenantConfigModule {}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/temporalTenantConfig/workflow-runtime-health.controller.ts

@@ -0,0 +1,21 @@
+import {
+  Controller,
+  Get,
+  Headers,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { RuntimeConnectivityProbeService } from './runtime-connectivity-probe.service';
+
+@Controller('workflow-runtime/health')
+export class WorkflowRuntimeHealthController {
+  constructor(private readonly probes: RuntimeConnectivityProbeService) {}
+
+  @Get('ready')
+  @AllowUnauthorizedRequest()
+  readiness(@Headers('x-workflow-runtime-probe') probe = '') {
+    if (!this.probes.verify(probe))
+      throw new UnauthorizedException('Invalid workflow runtime probe');
+    return { status: 'ok' };
+  }
+}

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

@@ -5,7 +5,7 @@ describe('validateDslGraph', () => {
     nodes: [
       { id: 't1', type: 'manual_trigger' },
       { id: 'n1', type: 'http_request' },
-      { id: 'n2', type: 'send_notification' },
+      { id: 'n2', type: 'code' },
     ],
     edges: [
       { source: 't1', target: 'n1' },
@@ -25,7 +25,7 @@ describe('validateDslGraph', () => {
             { id: 't1', type: 'manual_trigger' },
             { id: 'a', type: 'http_request' },
             { id: 'b', type: 'http_request' },
-            { id: 'c', type: 'send_notification' },
+            { id: 'c', type: 'code' },
           ],
           edges: [
             { source: 't1', target: 'a' },

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

@@ -15,27 +15,18 @@ const validDsl = {
       },
     },
     { id: 'http', type: 'http_request', config: {} },
-    {
-      id: 'return',
-      type: 'return_result',
-      config: {
-        resultType: 'APPROVAL_SUBJECTS',
-        sourceMode: 'INPUT',
-      },
-    },
+    { id: 'return', type: 'return_result', config: {} },
   ],
   edges: [{ source: 'http', target: 'return', kind: 'FLOW' }],
 };
 
 describe('callable Workflow contract', () => {
-  it('describes declared inputs and normalized result type', () => {
+  it('describes declared inputs and a returning workflow without a result type', () => {
     expect(describeCallableWorkflow(validDsl)).toEqual({
       mode: 'RETURN',
       inputParameters: [
         { key: 'employeeId', label: '员工 ID', required: true },
       ],
-      resultType: 'APPROVAL_SUBJECTS',
-      sourceMode: 'INPUT',
     });
   });
 
@@ -51,18 +42,13 @@ describe('callable Workflow contract', () => {
     ).toThrow('不能同时包含其他触发器');
   });
 
-  it('describes a callable Workflow without a return node as one-way', () => {
-    expect(
+  it('rejects a callable Workflow without a return node', () => {
+    expect(() =>
       validateCallableWorkflow({
         ...validDsl,
         nodes: validDsl.nodes.filter((node) => node.type !== 'return_result'),
       }),
-    ).toEqual({
-      mode: 'ONE_WAY',
-      inputParameters: [
-        { key: 'employeeId', label: '员工 ID', required: true },
-      ],
-    });
+    ).toThrow('必须且只能包含一个“返回调用”节点');
   });
 
   it('rejects more than one return node', () => {
@@ -71,88 +57,30 @@ describe('callable Workflow contract', () => {
         ...validDsl,
         nodes: [
           ...validDsl.nodes,
-          {
-            id: 'return-2',
-            type: 'return_result',
-            config: {
-              resultType: 'APPROVAL_SUBJECTS',
-              sourceMode: 'WORKFLOW',
-              path: 'approvers',
-            },
-          },
+          { id: 'return-2', type: 'return_result', config: {} },
         ],
       }),
-    ).toThrow('最多包含一个“返回结果”节点');
-  });
-
-  it('accepts returning the previous pipeline result as input', () => {
-    expect(
-      validateCallableWorkflow({
-        ...validDsl,
-        nodes: validDsl.nodes.map((node) =>
-          node.type === 'return_result'
-            ? {
-                ...node,
-                config: {
-                  resultType: 'APPROVAL_SUBJECTS',
-                  sourceMode: 'INPUT',
-                },
-              }
-            : node,
-        ),
-        edges: [{ source: 'http', target: 'return', kind: 'FLOW' }],
-      }),
-    ).toEqual({
-      mode: 'RETURN',
-      inputParameters: [
-        { key: 'employeeId', label: '员工 ID', required: true },
-      ],
-      resultType: 'APPROVAL_SUBJECTS',
-      sourceMode: 'INPUT',
-    });
+    ).toThrow('必须且只能包含一个“返回调用”节点');
   });
 
-  it('rejects an input return node that is not connected', () => {
+  it('requires exactly one previous node', () => {
     expect(() =>
       validateCallableWorkflow({
         ...validDsl,
-        nodes: validDsl.nodes.map((node) =>
-          node.type === 'return_result'
-            ? {
-                ...node,
-                config: {
-                  resultType: 'APPROVAL_SUBJECTS',
-                  sourceMode: 'INPUT',
-                },
-              }
-            : node,
-        ),
         edges: [],
       }),
-    ).toThrow('返回结果前需要连接一个节点');
+    ).toThrow('“返回调用”前需要连接一个节点');
   });
 
-  it('accepts returning a field from Workflow data', () => {
-    expect(
+  it('requires the return node to be terminal', () => {
+    expect(() =>
       validateCallableWorkflow({
         ...validDsl,
-        nodes: validDsl.nodes.map((node) =>
-          node.type === 'return_result'
-            ? {
-                ...node,
-                config: {
-                  resultType: 'APPROVAL_SUBJECTS',
-                  sourceMode: 'WORKFLOW',
-                  path: 'approvers',
-                },
-              }
-            : node,
-        ),
+        edges: [
+          ...validDsl.edges,
+          { source: 'return', target: 'after', kind: 'FLOW' },
+        ],
       }),
-    ).toMatchObject({
-      resultType: 'APPROVAL_SUBJECTS',
-      sourceMode: 'WORKFLOW',
-      path: 'approvers',
-    });
+    ).toThrow('“返回调用”必须是流程最后一个节点');
   });
 });

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

@@ -1,32 +1,14 @@
-export type CallableResultType = 'APPROVAL_SUBJECTS';
-
 export interface CallableInputParameter {
   key: string;
   label?: string;
   required?: boolean;
 }
 
-interface CallableWorkflowBaseDescriptor {
+export interface CallableWorkflowDescriptor {
   inputParameters: CallableInputParameter[];
-}
-
-export interface OneWayCallableWorkflowDescriptor
-  extends CallableWorkflowBaseDescriptor {
-  mode: 'ONE_WAY';
-}
-
-export interface ReturningCallableWorkflowDescriptor
-  extends CallableWorkflowBaseDescriptor {
   mode: 'RETURN';
-  resultType: CallableResultType;
-  sourceMode: 'INPUT' | 'WORKFLOW';
-  path?: string;
 }
 
-export type CallableWorkflowDescriptor =
-  | OneWayCallableWorkflowDescriptor
-  | ReturningCallableWorkflowDescriptor;
-
 type DslLike = {
   nodes?: Array<{
     id?: unknown;
@@ -49,11 +31,11 @@ export function describeCallableWorkflow(
   return validateCallableWorkflow(dsl);
 }
 
-export function describeApprovalChannelInputs(
+export function describeReturningWorkflowInputs(
   dsl: unknown,
 ): CallableInputParameter[] {
   const descriptor = describeCallableWorkflow(dsl);
-  if (!descriptor || descriptor.mode !== 'ONE_WAY') return [];
+  if (!descriptor) return [];
   return descriptor.inputParameters;
 }
 
@@ -79,48 +61,30 @@ export function validateCallableWorkflow(
   const inputParameters = normalizeInputParameters(
     triggerConfig.inputParameters,
   );
-  if (returns.length === 0)
-    return {
-      mode: 'ONE_WAY',
-      inputParameters,
-    };
-  if (returns.length > 1)
-    throw new Error('可调用 Workflow 最多包含一个“返回结果”节点');
-
-  const returnConfig = asObject(returns[0].config);
-  if (returnConfig.resultType !== 'APPROVAL_SUBJECTS')
-    throw new Error('返回结果类型必须是审批人');
-
-  if (returnConfig.sourceMode === 'INPUT') {
-    const returnNodeId = returns[0].id;
-    const predecessors = (asDsl(dsl).edges ?? []).filter(
-      (edge) =>
-        edge.target === returnNodeId &&
-        (!edge.kind || edge.kind === 'FLOW') &&
-        !edge.pairId,
-    );
-    if (predecessors.length !== 1)
-      throw new Error('返回结果前需要连接一个节点');
-
-    return {
-      mode: 'RETURN',
-      inputParameters,
-      resultType: 'APPROVAL_SUBJECTS',
-      sourceMode: 'INPUT',
-    };
-  }
-
-  if (returnConfig.sourceMode !== 'WORKFLOW')
-    throw new Error('返回结果来源必须是上一个节点或 Workflow 数据');
-  if (typeof returnConfig.path !== 'string' || !returnConfig.path.trim())
-    throw new Error('返回 Workflow 数据时必须填写字段路径');
+  if (returns.length !== 1)
+    throw new Error('可调用 Workflow 必须且只能包含一个“返回调用”节点');
+
+  const returnNodeId = returns[0].id;
+  const predecessors = (asDsl(dsl).edges ?? []).filter(
+    (edge) =>
+      edge.target === returnNodeId &&
+      (!edge.kind || edge.kind === 'FLOW') &&
+      !edge.pairId,
+  );
+  if (predecessors.length !== 1)
+    throw new Error('“返回调用”前需要连接一个节点');
+  const successors = (asDsl(dsl).edges ?? []).filter(
+    (edge) =>
+      edge.source === returnNodeId &&
+      (!edge.kind || edge.kind === 'FLOW') &&
+      !edge.pairId,
+  );
+  if (successors.length > 0)
+    throw new Error('“返回调用”必须是流程最后一个节点');
 
   return {
     mode: 'RETURN',
     inputParameters,
-    resultType: 'APPROVAL_SUBJECTS',
-    sourceMode: 'WORKFLOW',
-    path: returnConfig.path.trim(),
   };
 }