@gadmin2n/schematics 0.0.147 → 0.0.149

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/approval-subject-source.util.ts

@@ -3,12 +3,11 @@ export type ApprovalSubjectProvider = 'USER' | 'USER_GROUP';
 export type ApprovalSubjectSource =
   | {
       source?: 'STATIC';
-      provider: ApprovalSubjectProvider;
+      provider?: ApprovalSubjectProvider;
       refs: string[];
     }
   | {
       source: 'DYNAMIC';
-      provider: ApprovalSubjectProvider;
       inputKey: string;
     };
 
@@ -21,50 +20,33 @@ export function materializeApprovalSubjects(
   sources: ApprovalSubjectSource[],
   dynamicInputs: Record<string, unknown> = {},
 ): MaterializedApprovalSubject[] {
-  const refsByProvider = new Map<ApprovalSubjectProvider, string[]>();
+  const refsByProvider = new Map<ApprovalSubjectProvider, Set<string>>();
 
   for (const source of sources) {
-    const refs =
+    const provider =
+      source.source === 'DYNAMIC' ? 'USER' : source.provider ?? 'USER';
+    const refs = normalizeRefs(
       source.source === 'DYNAMIC'
-        ? normalizeDynamicRefs(
-            dynamicInputs[source.inputKey],
-            source.inputKey,
-            source.provider,
-          )
-        : normalizeRefs(source.refs);
-    const current = refsByProvider.get(source.provider) ?? [];
-    refsByProvider.set(source.provider, [...new Set([...current, ...refs])]);
+        ? normalizeDynamicRefs(dynamicInputs[source.inputKey], source.inputKey)
+        : source.refs,
+    );
+    const combined = refsByProvider.get(provider) ?? new Set<string>();
+    refs.forEach((ref) => combined.add(ref));
+    refsByProvider.set(provider, combined);
   }
 
-  return [...refsByProvider].map(([provider, refs]) => ({ provider, refs }));
+  return [...refsByProvider].flatMap(([provider, refs]) =>
+    refs.size ? [{ provider, refs: [...refs] }] : [],
+  );
 }
 
-function normalizeDynamicRefs(
-  value: unknown,
-  inputKey: string,
-  provider: ApprovalSubjectProvider,
-): string[] {
-  const result = asObject(value);
-  const subjects = Array.isArray(result.subjects) ? result.subjects : [];
-  const refs = normalizeRefs(
-    subjects.flatMap((item) => {
-      const subject = asObject(item);
-      return subject.provider === provider && Array.isArray(subject.refs)
-        ? subject.refs
-        : [];
-    }),
-  );
+function normalizeDynamicRefs(value: unknown, inputKey: string): string[] {
+  const refs = Array.isArray(value) ? normalizeRefs(value) : [];
   if (refs.length === 0)
     throw new Error(`Dynamic approver input "${inputKey}" is missing or empty`);
   return refs;
 }
 
-function asObject(value: unknown): Record<string, unknown> {
-  return value && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-}
-
 function normalizeRefs(values: unknown[]): string[] {
   return [
     ...new Set(

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/human-approval.dto.ts

@@ -20,9 +20,9 @@ export class ApprovalSubjectConfigDto {
   @IsIn(['STATIC', 'DYNAMIC'])
   source: 'STATIC' | 'DYNAMIC';
 
-  @IsString()
-  @IsNotEmpty()
-  provider: string;
+  @IsOptional()
+  @IsIn(['USER', 'USER_GROUP'])
+  provider?: 'USER' | 'USER_GROUP';
 
   @ValidateIf((input) => input.source === 'STATIC')
   @IsArray()

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

@@ -2,6 +2,65 @@ import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-co
 import { HumanApprovalService } from './human-approval.service';
 
 describe('HumanApprovalService', () => {
+  it('deduplicates people resolved from fixed users and fixed user groups', async () => {
+    const userProvider = {
+      preview: jest.fn().mockResolvedValue({
+        items: [{ ref: 'alice', label: 'Alice' }],
+      }),
+      resolve: jest.fn().mockResolvedValue([
+        {
+          principalType: 'USER',
+          principalRef: 'alice',
+          displayName: 'Alice',
+          sourceRefs: ['alice'],
+        },
+      ]),
+    };
+    const groupProvider = {
+      preview: jest.fn().mockResolvedValue({
+        items: [{ ref: 'finance', label: 'Finance' }],
+      }),
+      resolve: jest.fn().mockResolvedValue([
+        {
+          principalType: 'USER',
+          principalRef: 'alice',
+          displayName: 'Alice',
+          sourceRefs: ['finance'],
+        },
+        {
+          principalType: 'USER',
+          principalRef: 'bob',
+          displayName: 'Bob',
+          sourceRefs: ['finance'],
+        },
+      ]),
+    };
+    const service = new HumanApprovalService(
+      {} as any,
+      {
+        get: jest.fn((key) =>
+          key === 'USER_GROUP' ? groupProvider : userProvider,
+        ),
+      } as any,
+    );
+
+    const result = await (service as any).resolveSubjects(
+      [
+        { provider: 'USER', refs: ['alice'] },
+        { provider: 'USER_GROUP', refs: ['finance'] },
+      ],
+      { userId: 'runtime' },
+    );
+
+    expect(result.candidates).toEqual([
+      expect.objectContaining({
+        principalRef: 'alice',
+        sourceRefs: ['alice', 'finance'],
+      }),
+      expect.objectContaining({ principalRef: 'bob' }),
+    ]);
+  });
+
   it('stores the resolved task in the built-in approval request', async () => {
     const create = jest.fn().mockResolvedValue({
       id: BigInt(40),
@@ -56,9 +115,7 @@ describe('HumanApprovalService', () => {
         },
         details: [],
       },
-      subjects: [
-        { source: 'STATIC' as const, provider: 'USER', refs: ['alice'] },
-      ],
+      subjects: [{ source: 'STATIC' as const, refs: ['alice'] }],
       approvalRule: { mode: 'ANY' as const },
       rejectionRule: { mode: 'ANY' as const },
       timeout: { durationSeconds: 0, action: 'REJECTED' as const },
@@ -227,9 +284,7 @@ describe('HumanApprovalService', () => {
         callbackResult: { script: 'return callback.body;' },
       },
       task: {},
-      subjects: [
-        { source: 'STATIC' as const, provider: 'USER', refs: ['alice'] },
-      ],
+      subjects: [{ source: 'STATIC' as const, refs: ['alice'] }],
       approvalRule: { mode: 'ANY' as const },
       rejectionRule: { mode: 'ANY' as const },
       timeout: { durationSeconds: 60, action: 'REJECTED' as const },

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/runtime/human-approval-runtime.controller.spec.ts

@@ -67,7 +67,7 @@ describe('HumanApprovalRuntimeController', () => {
         },
         details: [],
       },
-      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['reviewer'] }],
+      subjects: [{ source: 'STATIC', refs: ['reviewer'] }],
       approvalRule: { mode: 'ANY' },
       rejectionRule: { mode: 'ANY' },
       timeout: { durationSeconds: 0, action: 'REJECTED' },
@@ -113,7 +113,7 @@ describe('HumanApprovalRuntimeController', () => {
   it('reuses a completed approval from the original retry operation', async () => {
     const config = {
       task: { title: { source: 'FIXED', value: '采购审批' }, details: [] },
-      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['reviewer'] }],
+      subjects: [{ source: 'STATIC', refs: ['reviewer'] }],
       approvalRule: { mode: 'ANY' },
       rejectionRule: { mode: 'ANY' },
       timeout: { durationSeconds: 0, action: 'REJECTED' },

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,
+    });
+  });
+});