@gadmin2n/schematics 0.0.150 → 0.0.152

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

@@ -13,13 +13,16 @@ import {
   Body,
   Controller,
   Delete,
+  Get,
   Inject,
   NotFoundException,
   Param,
   ParseIntPipe,
   Patch,
   Post,
+  Query,
   Req,
+  UnauthorizedException,
   UploadedFile,
   UseGuards,
   UseInterceptors,
@@ -43,6 +46,9 @@ import {
 } from '../../generated/resource/dto/resource-types.dto';
 import { UpdateResourceDto } from '../../generated/resource/dto/update-resource.dto';
 import { ResourceEntity } from '../../generated/resource/entities/resource.entity';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { ImportPayloadDto } from '../permTransfer/perm-transfer.dto';
+import { ResourceTransferService } from '../permTransfer/resource-transfer.service';
 import { ResourceService } from './resource.service';
 
 import { ConfigService } from '@nestjs/config';
@@ -54,6 +60,7 @@ import { FileInterceptor } from '@nestjs/platform-express';
 export class ResourceController {
   constructor(
     private readonly resourceService: ResourceService,
+    private readonly resourceTransferService: ResourceTransferService,
     private readonly config: ConfigService,
     @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
   ) {}
@@ -173,6 +180,54 @@ export class ResourceController {
     return res;
   }
 
+  // ─── Export/Import (cross-environment transfer) ────────────────────────────
+
+  @Post(':code/export-token')
+  @UseRoles({
+    resource: 'resource',
+    action: 'read',
+    possession: 'any',
+  })
+  async generateExportToken(@Param('code') code: string, @Req() req) {
+    const baseUrl = `${req.protocol}://${req.get('host')}/api`;
+    return this.resourceTransferService.generateExportToken(code, baseUrl);
+  }
+
+  @Get('export/:code')
+  @AllowUnauthorizedRequest()
+  async getExportPayload(
+    @Param('code') code: string,
+    @Query('token') token: string,
+  ) {
+    if (!token) {
+      throw new UnauthorizedException('Export token is required');
+    }
+    return this.resourceTransferService.getExportPayload(code, token);
+  }
+
+  @Post('import-preview')
+  @UseRoles({
+    resource: 'resource',
+    action: 'update',
+    possession: 'any',
+  })
+  async importPreview(@Body() dto: ImportPayloadDto) {
+    return this.resourceTransferService.importPreview(dto.payload);
+  }
+
+  @Post('import-confirm')
+  @UseRoles({
+    resource: 'resource',
+    action: 'update',
+    possession: 'any',
+  })
+  async importConfirm(@Body() dto: ImportPayloadDto, @Req() req) {
+    return this.resourceTransferService.importConfirm(
+      dto.payload,
+      req.user.username ?? req.user.userid,
+    );
+  }
+
   @Post('upload')
   @UseRoles({
     resource: 'resource',

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

@@ -1,8 +1,10 @@
 import { Module } from '@nestjs/common';
+import { PermTransferModule } from '../permTransfer/perm-transfer.module';
 import { ResourceController } from './resource.controller';
 import { ResourceService } from './resource.service';
 
 @Module({
+  imports: [PermTransferModule],
   controllers: [ResourceController],
   providers: [ResourceService],
   exports: [ResourceService],

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

@@ -13,13 +13,16 @@ import {
   Body,
   Controller,
   Delete,
+  Get,
   Inject,
   NotFoundException,
   Param,
   ParseIntPipe,
   Patch,
   Post,
+  Query,
   Req,
+  UnauthorizedException,
   UploadedFile,
   UseGuards,
   UseInterceptors,
@@ -43,6 +46,9 @@ import {
 } from '../../generated/role/dto/role-types.dto';
 import { UpdateRoleDto } from '../../generated/role/dto/update-role.dto';
 import { RoleEntity } from '../../generated/role/entities/role.entity';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { ImportPayloadDto } from '../permTransfer/perm-transfer.dto';
+import { RoleTransferService } from '../permTransfer/role-transfer.service';
 import { RoleService } from './role.service';
 
 import { ConfigService } from '@nestjs/config';
@@ -71,6 +77,7 @@ export class CreateRoleWithPagesDto extends CreateRoleDto {
 export class RoleController {
   constructor(
     private readonly roleService: RoleService,
+    private readonly roleTransferService: RoleTransferService,
     private readonly config: ConfigService,
     @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
   ) {}
@@ -187,6 +194,54 @@ export class RoleController {
     return res;
   }
 
+  // ─── Export/Import (cross-environment transfer) ────────────────────────────
+
+  @Post(':name/export-token')
+  @UseRoles({
+    resource: 'role',
+    action: 'read',
+    possession: 'any',
+  })
+  async generateExportToken(@Param('name') name: string, @Req() req) {
+    const baseUrl = `${req.protocol}://${req.get('host')}/api`;
+    return this.roleTransferService.generateExportToken(name, baseUrl);
+  }
+
+  @Get('export/:name')
+  @AllowUnauthorizedRequest()
+  async getExportPayload(
+    @Param('name') name: string,
+    @Query('token') token: string,
+  ) {
+    if (!token) {
+      throw new UnauthorizedException('Export token is required');
+    }
+    return this.roleTransferService.getExportPayload(name, token);
+  }
+
+  @Post('import-preview')
+  @UseRoles({
+    resource: 'role',
+    action: 'update',
+    possession: 'any',
+  })
+  async importPreview(@Body() dto: ImportPayloadDto) {
+    return this.roleTransferService.importPreview(dto.payload);
+  }
+
+  @Post('import-confirm')
+  @UseRoles({
+    resource: 'role',
+    action: 'update',
+    possession: 'any',
+  })
+  async importConfirm(@Body() dto: ImportPayloadDto, @Req() req) {
+    return this.roleTransferService.importConfirm(
+      dto.payload,
+      req.user.username ?? req.user.userid,
+    );
+  }
+
   @Post('upload')
   @UseRoles({
     resource: 'role',

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

@@ -1,10 +1,12 @@
 import { Module } from '@nestjs/common';
 import { PrismaService } from 'nestjs-prisma';
+import { PermTransferModule } from '../permTransfer/perm-transfer.module';
 import { RoleController } from './role.controller';
 import { RoleService } from './role.service';
 import { RolesRefresherService } from './roles-refresher.service';
 
 @Module({
+  imports: [PermTransferModule],
   providers: [RoleService, RolesRefresherService, PrismaService],
   controllers: [RoleController],
   exports: [RoleService],

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

@@ -0,0 +1,46 @@
+import { UserGroupDomainError } from '../../userGroup/user-group.errors';
+import { UserGroupProvider } from './user-group.provider';
+
+function createHarness() {
+  const groups = {
+    search: jest.fn(),
+    resolveUsers: jest.fn(),
+  };
+  return {
+    groups,
+    provider: new UserGroupProvider(groups as never),
+  };
+}
+
+describe('UserGroupProvider', () => {
+  it('returns the active state supplied by the user group service', async () => {
+    const { groups, provider } = createHarness();
+    groups.search.mockResolvedValue([
+      {
+        code: 'finance',
+        name: 'Finance',
+        description: null,
+        isActive: false,
+        revision: 2,
+      },
+    ]);
+
+    await expect(provider.search('', { userId: 'admin' })).resolves.toEqual([
+      expect.objectContaining({ ref: 'finance', active: false }),
+    ]);
+  });
+
+  it('preserves domain errors while resolving a user group', async () => {
+    const { groups, provider } = createHarness();
+    const error = new UserGroupDomainError(
+      'USER_GROUP_NOT_FOUND',
+      'User group not found: missing',
+      404,
+    );
+    groups.resolveUsers.mockRejectedValue(error);
+
+    await expect(
+      provider.resolve(['missing'], { actor: { userId: 'admin' } }),
+    ).rejects.toBe(error);
+  });
+});

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

@@ -62,7 +62,7 @@ export class UserGroupProvider implements SubjectProvider {
         ref: group.code,
         label: group.name,
         ...(group.description ? { description: group.description } : {}),
-        active: true,
+        active: group.isActive,
         revision: group.revision,
       }));
     } catch (error) {
@@ -177,7 +177,8 @@ export class UserGroupProvider implements SubjectProvider {
           );
         }
       }
-    } catch {
+    } catch (error) {
+      if (error instanceof UserGroupDomainError) throw error;
       throw new SubjectProviderUnavailableError(this.key);
     }
     return [...principals.values()].sort((a, b) =>

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

@@ -13,13 +13,16 @@ import {
   Body,
   Controller,
   Delete,
+  Get,
   Inject,
   NotFoundException,
   Param,
   ParseIntPipe,
   Patch,
   Post,
+  Query,
   Req,
+  UnauthorizedException,
   UploadedFile,
   UseGuards,
   UseInterceptors,
@@ -43,6 +46,9 @@ import {
   UserWhereSelect,
 } from '../../generated/user/dto/user-types.dto';
 import { UserEntity } from '../../generated/user/entities/user.entity';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { ImportPayloadDto } from '../permTransfer/perm-transfer.dto';
+import { UserTransferService } from '../permTransfer/user-transfer.service';
 import { UserService } from './user.service';
 
 import { ConfigService } from '@nestjs/config';
@@ -55,6 +61,7 @@ import * as path from 'path';
 export class UserController {
   constructor(
     private readonly userService: UserService,
+    private readonly userTransferService: UserTransferService,
     private readonly config: ConfigService,
     @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
   ) {
@@ -186,6 +193,54 @@ export class UserController {
     return this.userService.deletePerson(id);
   }
 
+  // ─── Export/Import (cross-environment transfer) ────────────────────────────
+
+  @Post(':userid/export-token')
+  @UseRoles({
+    resource: 'user',
+    action: 'read',
+    possession: 'any',
+  })
+  async generateExportToken(@Param('userid') userid: string, @Req() req) {
+    const baseUrl = `${req.protocol}://${req.get('host')}/api`;
+    return this.userTransferService.generateExportToken(userid, baseUrl);
+  }
+
+  @Get('export/:userid')
+  @AllowUnauthorizedRequest()
+  async getExportPayload(
+    @Param('userid') userid: string,
+    @Query('token') token: string,
+  ) {
+    if (!token) {
+      throw new UnauthorizedException('Export token is required');
+    }
+    return this.userTransferService.getExportPayload(userid, token);
+  }
+
+  @Post('import-preview')
+  @UseRoles({
+    resource: 'user',
+    action: 'update',
+    possession: 'any',
+  })
+  async importPreview(@Body() dto: ImportPayloadDto) {
+    return this.userTransferService.importPreview(dto.payload);
+  }
+
+  @Post('import-confirm')
+  @UseRoles({
+    resource: 'user',
+    action: 'update',
+    possession: 'any',
+  })
+  async importConfirm(@Body() dto: ImportPayloadDto, @Req() req) {
+    return this.userTransferService.importConfirm(
+      dto.payload,
+      req.user.username ?? req.user.userid,
+    );
+  }
+
   @Post('upload')
   @UseRoles({
     resource: 'user',

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

@@ -1,8 +1,10 @@
 import { Module } from '@nestjs/common';
+import { PermTransferModule } from '../permTransfer/perm-transfer.module';
 import { UserController } from './user.controller';
 import { UserService } from './user.service';
 
 @Module({
+  imports: [PermTransferModule],
   controllers: [UserController],
   providers: [UserService],
   exports: [UserService],

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

@@ -57,6 +57,7 @@ describe('Workflow cancellation', () => {
       temporal as any,
       {} as any,
       {} as any,
+      {} as any,
     );
     const runtime = new WorkflowRuntimeFacade(service);
     return { prisma, runtime, service, temporal, tx };

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

@@ -677,6 +677,57 @@ describe('WorkflowCompilerService', () => {
     });
   });
 
+  it('validates the failure callback connection on an event trigger', async () => {
+    const findConnection = jest.fn().mockResolvedValue({ isEnabled: true });
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(8),
+            type: 'event_trigger',
+            runtimeKey: 'event_trigger',
+            instancePolicy: 'OPTIONAL',
+            schemaVersion: 6,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      integrationConnection: { findUnique: findConnection },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await service.compile(
+      {
+        nodes: [
+          {
+            id: 'event',
+            type: 'event_trigger',
+            config: {
+              failureCallback: {
+                connectionRef: 'hardware-service',
+                path: '/api/hardware-disposal/workflow-failed',
+              },
+            },
+          },
+        ],
+        edges: [],
+      },
+      { userId: 'author' },
+    );
+
+    expect(findConnection).toHaveBeenCalledWith({
+      where: { code: 'hardware-service' },
+      select: { isEnabled: true },
+    });
+  });
+
   it('validates required inputs from the selected published version', async () => {
     const findWorkflow = jest.fn().mockResolvedValue({
       status: 'PUBLISHED',
@@ -898,7 +949,7 @@ describe('WorkflowCompilerService', () => {
     ).resolves.toBeUndefined();
   });
 
-  it('rejects a data-modifying statement when database writes are disabled', async () => {
+  it('rejects legacy raw SQL database configuration', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -907,7 +958,7 @@ describe('WorkflowCompilerService', () => {
             type: 'db_execute',
             runtimeKey: 'db_execute',
             instancePolicy: 'INLINE_ONLY',
-            schemaVersion: 2,
+            schemaVersion: 5,
             configSchema: { type: 'object' },
             uiSchema: {},
           },
@@ -930,8 +981,8 @@ describe('WorkflowCompilerService', () => {
               id: 'database-1',
               type: 'db_execute',
               config: {
-                allowWrite: false,
-                sql: 'WITH removed AS (DELETE FROM users RETURNING id) SELECT * FROM removed',
+                allowWrite: true,
+                sql: 'UPDATE users SET active = false',
               },
             },
           ],
@@ -941,13 +992,13 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: '当前数据库操作节点只允许单条只读查询',
+        message: '数据库节点不再支持 SQL，请选择 workflow_api 中的 Function',
         nodeId: 'database-1',
       },
     });
   });
 
-  it('accepts a single data write when database writes are enabled', async () => {
+  it('accepts a registered workflow_api Function with matching arguments', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -963,6 +1014,18 @@ describe('WorkflowCompilerService', () => {
         ]),
       },
       workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      $queryRaw: jest.fn().mockResolvedValue([
+        {
+          schema: 'workflow_api',
+          name: 'approve_request',
+          identity_arguments: 'p_request_id bigint, p_approved boolean',
+          return_type: 'jsonb',
+          arguments: [
+            { position: 1, name: 'p_request_id', type: 'bigint' },
+            { position: 2, name: 'p_approved', type: 'boolean' },
+          ],
+        },
+      ]),
     };
     const service = new WorkflowCompilerService(
       prisma as any,
@@ -979,8 +1042,15 @@ describe('WorkflowCompilerService', () => {
               id: 'database-1',
               type: 'db_execute',
               config: {
-                allowWrite: true,
-                sql: 'UPDATE users SET active = $1 WHERE id = $2',
+                functionRef: {
+                  schema: 'workflow_api',
+                  name: 'approve_request',
+                  identityArguments: 'p_request_id bigint, p_approved boolean',
+                },
+                argumentBindings: [
+                  { source: 'INPUT', path: 'requestId' },
+                  { source: 'FIXED', valueType: 'BOOLEAN', value: 'true' },
+                ],
               },
             },
           ],
@@ -992,13 +1062,17 @@ describe('WorkflowCompilerService', () => {
       nodes: [
         expect.objectContaining({
           id: 'database-1',
-          config: expect.objectContaining({ allowWrite: true }),
+          config: expect.objectContaining({
+            functionRef: expect.objectContaining({
+              name: 'approve_request',
+            }),
+          }),
         }),
       ],
     });
   });
 
-  it('accepts one writable CTE when database writes are enabled', async () => {
+  it('rejects a Function whose signature is not in the database catalog', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -1014,6 +1088,7 @@ describe('WorkflowCompilerService', () => {
         ]),
       },
       workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      $queryRaw: jest.fn().mockResolvedValue([]),
     };
     const service = new WorkflowCompilerService(
       prisma as any,
@@ -1030,8 +1105,12 @@ describe('WorkflowCompilerService', () => {
               id: 'database-1',
               type: 'db_execute',
               config: {
-                allowWrite: true,
-                sql: 'WITH changed AS (UPDATE requests SET status = $1 RETURNING id) UPDATE assets SET state = $2 WHERE request_id IN (SELECT id FROM changed)',
+                functionRef: {
+                  schema: 'workflow_api',
+                  name: 'missing_function',
+                  identityArguments: 'p_id bigint',
+                },
+                argumentBindings: [{ source: 'INPUT', path: 'id' }],
               },
             },
           ],
@@ -1039,8 +1118,11 @@ describe('WorkflowCompilerService', () => {
         },
         { userId: 'author' },
       ),
-    ).resolves.toMatchObject({
-      nodes: [expect.objectContaining({ id: 'database-1' })],
+    ).rejects.toMatchObject({
+      response: {
+        message: '选择的数据库 Function 不存在或已不再开放给 Workflow',
+        nodeId: 'database-1',
+      },
     });
   });
 });