@gadmin2n/schematics 0.0.146 → 0.0.148

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

@@ -5,6 +5,7 @@ import { ExternalInteractionModule } from './externalInteraction/externalInterac
 import { HttpRequestModule } from './httpRequest/httpRequest.module';
 import { HumanApprovalModule } from './humanApproval/humanApproval.module';
 import { IntegrationConnectionModule } from './integrationConnection/integrationConnection.module';
+import { StaffDirectoryModule } from './staffDirectory/staffDirectory.module';
 import { SubjectProviderModule } from './subjectProvider/subjectProvider.module';
 import { UserGroupModule } from './userGroup/userGroup.module';
 import { WorkflowModule } from './workflow/workflow.module';
@@ -17,6 +18,7 @@ export default [
   HumanApprovalModule,
   HttpRequestModule,
   IntegrationConnectionModule,
+  StaffDirectoryModule,
   WorkflowModule,
   SubjectProviderModule,
   UserGroupModule,

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

@@ -2,6 +2,7 @@ import { ACGuard } from '@gadmin2n/nest-common';
 import {
   Body,
   Controller,
+  Delete,
   Get,
   Header,
   Param,
@@ -87,4 +88,14 @@ export class IntegrationConnectionController {
   ) {
     return this.service.update(code, input, actorContextFromRequest(request));
   }
+
+  @Delete(':code')
+  @UseRoles({
+    resource: 'integrationConnection',
+    action: 'delete',
+    possession: 'any',
+  })
+  remove(@Param('code') code: string) {
+    return this.service.remove(code);
+  }
 }

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

@@ -41,4 +41,130 @@ describe('IntegrationConnectionService', () => {
     );
     await expect(service.getSecrets(entity.code)).resolves.toEqual(secrets);
   });
+
+  it('rejects deletion when a published Workflow references the connection', async () => {
+    const deleteConnection = jest.fn();
+    const prisma = {
+      integrationConnection: {
+        findUnique: jest.fn().mockResolvedValue({ code: 'ticket-api' }),
+        delete: deleteConnection,
+      },
+      workflow: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(7),
+            name: '工单审批',
+            dsl: null,
+            versions: [
+              {
+                version: 2,
+                dsl: {
+                  nodes: [
+                    {
+                      id: 'send-ticket',
+                      config: { connectionRef: 'ticket-api' },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn() },
+    };
+    const service = new IntegrationConnectionService(prisma as any, {} as any);
+
+    await expect(service.remove('ticket-api')).rejects.toMatchObject({
+      response: {
+        code: 'INTEGRATION_CONNECTION_IN_USE',
+        callers: [
+          {
+            workflowId: '7',
+            workflowName: '工单审批',
+            source: 'PUBLISHED',
+            version: 2,
+          },
+        ],
+      },
+    });
+    expect(deleteConnection).not.toHaveBeenCalled();
+  });
+
+  it('rejects deletion when a draft uses a referenced Node Instance connection', async () => {
+    const deleteConnection = jest.fn();
+    const prisma = {
+      integrationConnection: {
+        findUnique: jest.fn().mockResolvedValue({ code: 'ticket-api' }),
+        delete: deleteConnection,
+      },
+      workflow: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(8),
+            name: '资产审批',
+            dsl: {
+              nodes: [
+                {
+                  id: 'notify',
+                  instanceRef: {
+                    instanceId: '12',
+                    instanceCode: 'NOTIFY',
+                  },
+                },
+              ],
+            },
+            versions: [],
+          },
+        ]),
+      },
+      workflowNodeInstance: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(12),
+            config: {
+              external: {
+                request: { connectionRef: 'ticket-api' },
+              },
+            },
+          },
+        ]),
+      },
+    };
+    const service = new IntegrationConnectionService(prisma as any, {} as any);
+
+    await expect(service.remove('ticket-api')).rejects.toMatchObject({
+      response: {
+        code: 'INTEGRATION_CONNECTION_IN_USE',
+        callers: [
+          {
+            workflowId: '8',
+            workflowName: '资产审批',
+            source: 'DRAFT',
+          },
+        ],
+      },
+    });
+    expect(deleteConnection).not.toHaveBeenCalled();
+  });
+
+  it('deletes an unreferenced connection', async () => {
+    const deleteConnection = jest.fn().mockResolvedValue({});
+    const prisma = {
+      integrationConnection: {
+        findUnique: jest.fn().mockResolvedValue({ code: 'ticket-api' }),
+        delete: deleteConnection,
+      },
+      workflow: { findMany: jest.fn().mockResolvedValue([]) },
+      workflowNodeInstance: { findMany: jest.fn() },
+    };
+    const service = new IntegrationConnectionService(prisma as any, {} as any);
+
+    await expect(service.remove('ticket-api')).resolves.toEqual({
+      code: 'ticket-api',
+    });
+    expect(deleteConnection).toHaveBeenCalledWith({
+      where: { code: 'ticket-api' },
+    });
+  });
 });

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

@@ -135,6 +135,84 @@ export class IntegrationConnectionService {
     return this.get(code);
   }
 
+  async remove(code: string) {
+    await this.findOrThrow(code);
+    const workflows = await this.prisma.workflow.findMany({
+      select: {
+        id: true,
+        name: true,
+        dsl: true,
+        versions: { select: { version: true, dsl: true } },
+      },
+    });
+    const dsls = workflows.flatMap((workflow) => [
+      workflow.dsl,
+      ...workflow.versions.map((version) => version.dsl),
+    ]);
+    const referencedInstanceIds = [
+      ...new Set(dsls.flatMap((dsl) => referencedNodeInstanceIds(dsl))),
+    ];
+    const referencedInstances = referencedInstanceIds.length
+      ? await this.prisma.workflowNodeInstance.findMany({
+          where: {
+            id: { in: referencedInstanceIds.map((id) => BigInt(id)) },
+          },
+          select: { id: true, config: true },
+        })
+      : [];
+    const instanceConfigs = new Map(
+      referencedInstances.map((instance) => [
+        String(instance.id),
+        instance.config,
+      ]),
+    );
+    const callers: Array<{
+      workflowId: string;
+      workflowName: string;
+      source: 'DRAFT' | 'PUBLISHED';
+      version?: number;
+    }> = [];
+
+    for (const workflow of workflows) {
+      if (dslReferencesConnection(workflow.dsl, code, instanceConfigs))
+        callers.push({
+          workflowId: String(workflow.id),
+          workflowName: workflow.name,
+          source: 'DRAFT',
+        });
+      for (const version of workflow.versions) {
+        if (!dslReferencesConnection(version.dsl, code, instanceConfigs))
+          continue;
+        callers.push({
+          workflowId: String(workflow.id),
+          workflowName: workflow.name,
+          source: 'PUBLISHED',
+          version: version.version,
+        });
+      }
+    }
+
+    if (callers.length > 0) {
+      const workflowNames = [
+        ...new Set(callers.map((item) => item.workflowName)),
+      ];
+      const visibleNames = workflowNames.slice(0, 3).join('、');
+      const remaining = workflowNames.length - 3;
+      throw new ConflictException({
+        code: 'INTEGRATION_CONNECTION_IN_USE',
+        message:
+          '该连接仍被 Workflow ' +
+          visibleNames +
+          (remaining > 0 ? ' 等 ' + workflowNames.length + ' 个' : '') +
+          ' 使用，解除引用后才能删除',
+        callers,
+      });
+    }
+
+    await this.prisma.integrationConnection.delete({ where: { code } });
+    return { code };
+  }
+
   async resolveRuntime(code: string) {
     const entity = await this.findOrThrow(code);
     if (!entity.isEnabled)
@@ -281,3 +359,61 @@ function asObject(value: Prisma.JsonValue): Record<string, unknown> {
     ? (value as Record<string, unknown>)
     : {};
 }
+
+function referencedNodeInstanceIds(dsl: unknown): string[] {
+  return workflowNodes(dsl).flatMap((node) => {
+    if (isRecord(node.source)) return [];
+    const instanceId = String(asPlainObject(node.instanceRef).instanceId ?? '');
+    return /^[1-9]\d*$/.test(instanceId) ? [instanceId] : [];
+  });
+}
+
+function dslReferencesConnection(
+  dsl: unknown,
+  connectionCode: string,
+  instanceConfigs: Map<string, unknown>,
+): boolean {
+  return workflowNodes(dsl).some((node) => {
+    let effectiveConfig: unknown = node.config;
+    if (!isRecord(node.source)) {
+      if (isRecord(node.configOverride)) {
+        effectiveConfig = node.configOverride;
+      } else {
+        const instanceId = String(
+          asPlainObject(node.instanceRef).instanceId ?? '',
+        );
+        effectiveConfig = instanceConfigs.get(instanceId) ?? node.config;
+      }
+    }
+    return containsConnectionReference(effectiveConfig, connectionCode);
+  });
+}
+
+function workflowNodes(dsl: unknown): Array<Record<string, unknown>> {
+  const nodes = asPlainObject(dsl).nodes;
+  return Array.isArray(nodes) ? nodes.filter(isRecord) : [];
+}
+
+function containsConnectionReference(
+  value: unknown,
+  connectionCode: string,
+): boolean {
+  if (Array.isArray(value))
+    return value.some((item) =>
+      containsConnectionReference(item, connectionCode),
+    );
+  if (!isRecord(value)) return false;
+  return Object.entries(value).some(
+    ([key, item]) =>
+      (key === 'connectionRef' && item === connectionCode) ||
+      containsConnectionReference(item, connectionCode),
+  );
+}
+
+function asPlainObject(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

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

@@ -0,0 +1,24 @@
+import { ACGuard } from '@gadmin2n/nest-common';
+import { Controller, Get, Header, Query, UseGuards } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { UseRoles } from 'nest-access-control';
+import { SearchStaffDirectoryDto } from './staff-directory.dto';
+import { StaffDirectoryService } from './staff-directory.service';
+
+@ApiTags('staff-directory')
+@UseGuards(ACGuard)
+@Controller('staff-directory')
+export class StaffDirectoryController {
+  constructor(private readonly service: StaffDirectoryService) {}
+
+  @Get('search')
+  @Header('Cache-Control', 'no-store')
+  @UseRoles({
+    resource: 'staffDirectory',
+    action: 'read',
+    possession: 'any',
+  })
+  search(@Query() query: SearchStaffDirectoryDto) {
+    return this.service.search(query.keyword ?? '');
+  }
+}

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

@@ -0,0 +1,8 @@
+import { IsOptional, IsString, MaxLength } from 'class-validator';
+
+export class SearchStaffDirectoryDto {
+  @IsOptional()
+  @IsString()
+  @MaxLength(128)
+  keyword?: string;
+}

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

@@ -0,0 +1,62 @@
+import axios from 'axios';
+import { StaffDirectoryService } from './staff-directory.service';
+
+describe('StaffDirectoryService', () => {
+  afterEach(() => jest.restoreAllMocks());
+
+  it('calls ERP with the server-side API key and normalizes people', async () => {
+    const request = jest.spyOn(axios, 'request').mockResolvedValue({
+      data: [
+        {
+          staffAccountName: 'junrujrwang',
+          staffDisplayName: 'Junru Wang',
+          bgNameEn: 'OIT',
+          deptNameEn: 'Operations',
+        },
+      ],
+    });
+    const service = new StaffDirectoryService({
+      get: jest.fn(
+        (key: string) =>
+          ({
+            'staffDirectory.baseUrl': 'https://erp.example.com/',
+            'staffDirectory.apiKey': 'secret',
+            'staffDirectory.searchPath': '/api/staff/search',
+          }[key]),
+      ),
+    } as never);
+
+    await expect(service.search(' junru ')).resolves.toEqual([
+      {
+        userId: 'junrujrwang',
+        displayName: 'Junru Wang',
+        businessGroup: 'OIT',
+        department: 'Operations',
+      },
+    ]);
+    expect(request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://erp.example.com/api/staff/search',
+        params: { keyword: 'junru' },
+        headers: { 'X-API-KEY': 'secret' },
+      }),
+    );
+  });
+
+  it('returns no results without calling ERP for an empty keyword', async () => {
+    const request = jest.spyOn(axios, 'request');
+    const service = new StaffDirectoryService({ get: jest.fn() } as never);
+
+    await expect(service.search('  ')).resolves.toEqual([]);
+    expect(request).not.toHaveBeenCalled();
+  });
+
+  it('reports missing server configuration without exposing secrets', async () => {
+    const service = new StaffDirectoryService({ get: jest.fn() } as never);
+
+    await expect(service.search('alice')).rejects.toMatchObject({
+      response: { code: 'STAFF_DIRECTORY_NOT_CONFIGURED' },
+      status: 503,
+    });
+  });
+});

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

@@ -0,0 +1,94 @@
+import {
+  BadGatewayException,
+  Injectable,
+  ServiceUnavailableException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+import { StaffDirectoryPerson } from './staff-directory.types';
+
+interface UpstreamStaff {
+  staffAccountName?: unknown;
+  staffDisplayName?: unknown;
+  bgNameEn?: unknown;
+  deptNameEn?: unknown;
+}
+
+@Injectable()
+export class StaffDirectoryService {
+  constructor(private readonly config: ConfigService) {}
+
+  async search(keyword: string): Promise<StaffDirectoryPerson[]> {
+    const query = keyword.trim();
+    if (!query) return [];
+
+    const baseUrl = this.config
+      .get<string>('staffDirectory.baseUrl')
+      ?.trim()
+      .replace(/\/$/, '');
+    const apiKey = this.config.get<string>('staffDirectory.apiKey')?.trim();
+    const searchPath = normalizeSearchPath(
+      this.config.get<string>('staffDirectory.searchPath'),
+    );
+    if (!baseUrl || !apiKey) {
+      throw new ServiceUnavailableException({
+        code: 'STAFF_DIRECTORY_NOT_CONFIGURED',
+        message:
+          'Staff directory is not configured; set STAFF_DIRECTORY_BASE_URL and STAFF_DIRECTORY_API_KEY',
+      });
+    }
+
+    try {
+      const response = await axios.request<unknown>({
+        url: `${baseUrl}${searchPath}`,
+        method: 'GET',
+        params: { keyword: query },
+        headers: { 'X-API-KEY': apiKey },
+        timeout: 5000,
+        maxRedirects: 0,
+        validateStatus: (status) => status >= 200 && status < 300,
+      });
+      if (!Array.isArray(response.data)) throw new Error('invalid response');
+      return [
+        ...new Map(
+          response.data
+            .flatMap(normalizePerson)
+            .map((person) => [person.userId, person]),
+        ).values(),
+      ];
+    } catch {
+      throw new BadGatewayException({
+        code: 'STAFF_DIRECTORY_UNAVAILABLE',
+        message: 'Staff directory search is temporarily unavailable',
+      });
+    }
+  }
+}
+
+function normalizeSearchPath(value?: string): string {
+  const path = value?.trim() || '/api/staff/search';
+  return path.startsWith('/') ? path : `/${path}`;
+}
+
+function normalizePerson(value: unknown): StaffDirectoryPerson[] {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return [];
+  const staff = value as UpstreamStaff;
+  const userId = stringValue(staff.staffAccountName);
+  if (!userId) return [];
+  return [
+    {
+      userId,
+      displayName: stringValue(staff.staffDisplayName) || userId,
+      ...(stringValue(staff.bgNameEn) && {
+        businessGroup: stringValue(staff.bgNameEn),
+      }),
+      ...(stringValue(staff.deptNameEn) && {
+        department: stringValue(staff.deptNameEn),
+      }),
+    },
+  ];
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/staffDirectory/staff-directory.types.ts

@@ -0,0 +1,6 @@
+export interface StaffDirectoryPerson {
+  userId: string;
+  displayName: string;
+  businessGroup?: string;
+  department?: string;
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { StaffDirectoryController } from './staff-directory.controller';
+import { StaffDirectoryService } from './staff-directory.service';
+
+@Module({
+  controllers: [StaffDirectoryController],
+  providers: [StaffDirectoryService],
+  exports: [StaffDirectoryService],
+})
+export class StaffDirectoryModule {}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/subjectProvider/providers/user.provider.ts

@@ -46,6 +46,7 @@ export class UserProvider implements SubjectProvider {
       const { entities } = await this.users.findMany({
         where: {
           isActive: true,
+          isApiKey: false,
           ...(q && {
             OR: [
               { userid: { contains: q, mode: 'insensitive' } },
@@ -132,8 +133,11 @@ export class UserProvider implements SubjectProvider {
   private async find(refs: string[]): Promise<User[]> {
     if (!refs.length) return [];
     try {
-      return (await this.users.findMany({ where: { userid: { in: refs } } }))
-        .entities;
+      return (
+        await this.users.findMany({
+          where: { userid: { in: refs }, isApiKey: false },
+        })
+      ).entities;
     } catch {
       throw new SubjectProviderUnavailableError(this.key);
     }

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

@@ -85,7 +85,6 @@ describe('TemporalTenantConfigController', () => {
       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(
@@ -120,34 +119,40 @@ describe('TemporalTenantConfigController', () => {
         dbUrl: 'postgresql://user:pass@gadmin-db:5432/gadmin_demo',
         displayName: 'Gadmin Test',
         runtimeBaseUrl: 'http://gadmin-server:8000/api',
-        runtimeToken: '0123456789abcdef0123456789abcdef',
+        runtimeToken: 'caller-controlled-runtime-token-value',
       } as any,
       (value) => value,
       { user: { username: 'admin' } } as any,
     );
 
+    const registrationRequest = (global.fetch as jest.Mock).mock.calls[0][1];
+    const registrationBody = JSON.parse(registrationRequest.body);
+
     expect(global.fetch).toHaveBeenCalledWith(
       'http://temporal.example:8081/admin/tenants',
       expect.objectContaining({
         method: 'POST',
-        body: JSON.stringify({
-          namespace: 'gadmin-test',
-          displayName: 'Gadmin Test',
-          dbUrl: 'postgresql://user:pass@gadmin-db:5432/gadmin_demo',
-          runtimeBaseUrl: 'http://gadmin-server:8000/api',
-          runtimeToken: '0123456789abcdef0123456789abcdef',
-        }),
       }),
     );
+    expect(registrationBody).toMatchObject({
+      namespace: 'gadmin-test',
+      displayName: 'Gadmin Test',
+      dbUrl: 'postgresql://user:pass@gadmin-db:5432/gadmin_demo',
+      runtimeBaseUrl: 'http://gadmin-server:8000/api',
+    });
+    expect(registrationBody.runtimeToken).toMatch(/^[0-9a-f]{64}$/);
+    expect(registrationBody.runtimeToken).not.toBe(
+      'caller-controlled-runtime-token-value',
+    );
     expect(mockTemporalTenantConfigService.createOne).toHaveBeenCalledWith({
       data: expect.objectContaining({
         runtimeBaseUrl: 'http://gadmin-server:8000/api',
-        runtimeToken: '0123456789abcdef0123456789abcdef',
+        runtimeToken: registrationBody.runtimeToken,
       }),
     });
   });
 
-  it('updates the tenant runtime connection in shared Temporal', async () => {
+  it('updates the tenant runtime connection without accepting a replacement token', async () => {
     global.fetch = jest.fn().mockResolvedValue({
       ok: true,
     });
@@ -175,9 +180,12 @@ describe('TemporalTenantConfigController', () => {
         method: 'PATCH',
         body: JSON.stringify({
           runtimeBaseUrl: 'http://gadmin-server:8000/api',
-          runtimeToken: '0123456789abcdef0123456789abcdef',
         }),
       }),
     );
+    expect(mockTemporalTenantConfigService.updateUnique).toHaveBeenCalledWith(
+      1,
+      expect.not.objectContaining({ runtimeToken: expect.anything() }),
+    );
   });
 });