@gadmin2n/schematics 0.0.147 → 0.0.149

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

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

@@ -50,6 +50,7 @@ import { TemporalTenantConfigService } from './temporalTenantConfig.service';
 
 import { ConfigService } from '@nestjs/config';
 import { FileInterceptor } from '@nestjs/platform-express';
+import { randomBytes } from 'crypto';
 
 @UseGuards(ACGuard)
 @Controller('temporalTenantConfig')
@@ -69,7 +70,6 @@ export class TemporalTenantConfigController {
     possession: 'any',
   })
   async testConnection(@Body() body: CreateTemporalTenantConfigDto) {
-    assertRuntimeToken(body.runtimeToken);
     let response: Response;
     const adminUrl = body.adminUrl.replace(/\/+$/, '');
 
@@ -117,8 +117,12 @@ export class TemporalTenantConfigController {
     @ACAttrFilter() acAttrFilter,
     @Req() request: Request & { user: UserType },
   ) {
-    assertRuntimeToken(body.runtimeToken);
-    body.creator = request.user.username;
+    const runtimeToken = randomBytes(32).toString('hex');
+    const registration = {
+      ...body,
+      creator: request.user.username,
+      runtimeToken,
+    };
 
     // 先调 shared temporal admin API（原子：失败则不写 DB）
     const res = await fetch(`${body.adminUrl}/admin/tenants`, {
@@ -132,7 +136,7 @@ export class TemporalTenantConfigController {
         displayName: body.displayName,
         dbUrl: body.dbUrl,
         runtimeBaseUrl: body.runtimeBaseUrl,
-        runtimeToken: body.runtimeToken,
+        runtimeToken,
       }),
     });
     if (!res.ok) {
@@ -144,7 +148,7 @@ export class TemporalTenantConfigController {
 
     return new TemporalTenantConfigEntity(
       await this.temporalTenantConfigService.createOne({
-        data: acAttrFilter(body),
+        data: acAttrFilter(registration),
       }),
     );
   }
@@ -210,7 +214,8 @@ export class TemporalTenantConfigController {
     @Body() body: UpdateTemporalTenantConfigDto,
     @ACAttrFilter() acAttrFilter,
   ) {
-    if (body.runtimeToken !== undefined) assertRuntimeToken(body.runtimeToken);
+    const editableBody = { ...body };
+    delete editableBody.runtimeToken;
     const existing = await this.temporalTenantConfigService.findUnique(id, {
       adminUrl: true,
       adminToken: true,
@@ -218,15 +223,17 @@ export class TemporalTenantConfigController {
     });
     if (!existing) throw new NotFoundException();
 
-    const adminUrl = (body.adminUrl ?? existing.adminUrl) as string;
-    const adminToken = (body.adminToken ?? existing.adminToken) as string;
-    const namespace = (body.namespace ?? existing.namespace) as string;
+    const adminUrl = (editableBody.adminUrl ?? existing.adminUrl) as string;
+    const adminToken = (editableBody.adminToken ??
+      existing.adminToken) as string;
+    const namespace = (editableBody.namespace ?? existing.namespace) as string;
 
     const patchBody: Record<string, string> = {};
-    if (body.dbUrl) patchBody.dbUrl = body.dbUrl;
-    if (body.displayName) patchBody.displayName = body.displayName;
-    if (body.runtimeBaseUrl) patchBody.runtimeBaseUrl = body.runtimeBaseUrl;
-    if (body.runtimeToken) patchBody.runtimeToken = body.runtimeToken;
+    if (editableBody.dbUrl) patchBody.dbUrl = editableBody.dbUrl;
+    if (editableBody.displayName)
+      patchBody.displayName = editableBody.displayName;
+    if (editableBody.runtimeBaseUrl)
+      patchBody.runtimeBaseUrl = editableBody.runtimeBaseUrl;
 
     if (Object.keys(patchBody).length > 0) {
       const res = await fetch(
@@ -250,7 +257,7 @@ export class TemporalTenantConfigController {
 
     const item = await this.temporalTenantConfigService.updateUnique(
       id,
-      acAttrFilter(body),
+      acAttrFilter(editableBody),
     );
     return new TemporalTenantConfigEntity(acAttrFilter(item));
   }
@@ -295,8 +302,3 @@ 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/user/user.controller.ts

@@ -175,6 +175,17 @@ export class UserController {
     return res;
   }
 
+  @Delete('deletePerson/:id')
+  @UseRoles({
+    resource: 'user',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  async deletePerson(@Param('id', ParseIntPipe) id: number) {
+    return this.userService.deletePerson(id);
+  }
+
   @Post('upload')
   @UseRoles({
     resource: 'user',

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

@@ -1,6 +1,8 @@
 /// <reference types="jest" />
+import { ConflictException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
+import { Prisma } from '@prisma/client';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 
 // Mock nestjs-prisma 模块
@@ -26,6 +28,12 @@ const mockPrismaService = {
     groupBy: jest.fn(),
     aggregate: jest.fn(),
   },
+  workflow: {
+    findMany: jest.fn(),
+  },
+  approvalCandidate: {
+    count: jest.fn(),
+  },
 };
 
 // Mock Logger
@@ -103,6 +111,28 @@ describe('UserService', () => {
         'Database connection failed',
       );
     });
+
+    it('returns a useful conflict when userid already exists', async () => {
+      prisma.user.create.mockRejectedValue(
+        new Prisma.PrismaClientKnownRequestError('duplicate userid', {
+          code: 'P2002',
+          clientVersion: '6.19.3',
+          meta: { target: ['userid'] },
+        }),
+      );
+
+      await expect(
+        service.createOne({
+          data: { userid: 'existing-user', roles: '[]' },
+        } as any),
+      ).rejects.toMatchObject({
+        constructor: ConflictException,
+        response: {
+          code: 'USER_ALREADY_EXISTS',
+          message: '该人员已存在，无需重复添加',
+        },
+      });
+    });
   });
 
   describe('createMany', () => {
@@ -133,6 +163,73 @@ describe('UserService', () => {
     });
   });
 
+  describe('deletePerson', () => {
+    it('deletes an unreferenced person without roles', async () => {
+      prisma.user.findUnique.mockResolvedValue({
+        userid: 'person-a',
+        roles: '[]',
+        groupMemberships: [],
+      });
+      prisma.workflow.findMany.mockResolvedValue([]);
+      prisma.approvalCandidate.count.mockResolvedValue(0);
+      prisma.user.delete.mockResolvedValue({ id: 10 });
+
+      await expect(service.deletePerson(10)).resolves.toEqual({ count: 1 });
+      expect(prisma.user.delete).toHaveBeenCalledWith({ where: { id: 10 } });
+    });
+
+    it('rejects deleting a person that still has a role', async () => {
+      prisma.user.findUnique.mockResolvedValue({
+        userid: 'admin-a',
+        roles: '["SYSTEM_ADMIN"]',
+        groupMemberships: [],
+      });
+      prisma.workflow.findMany.mockResolvedValue([]);
+      prisma.approvalCandidate.count.mockResolvedValue(0);
+
+      await expect(service.deletePerson(10)).rejects.toMatchObject({
+        response: {
+          code: 'PERSON_IN_USE',
+          roles: ['SYSTEM_ADMIN'],
+        },
+      });
+      expect(prisma.user.delete).not.toHaveBeenCalled();
+    });
+
+    it('rejects deleting a person referenced by a Workflow', async () => {
+      prisma.user.findUnique.mockResolvedValue({
+        userid: 'approver-a',
+        roles: '[]',
+        groupMemberships: [],
+      });
+      prisma.workflow.findMany.mockResolvedValue([
+        {
+          id: BigInt(7),
+          name: '资产审批',
+          dsl: {
+            nodes: [
+              {
+                config: {
+                  subjects: [{ source: 'STATIC', refs: ['approver-a'] }],
+                },
+              },
+            ],
+          },
+          versions: [],
+        },
+      ]);
+      prisma.approvalCandidate.count.mockResolvedValue(0);
+
+      await expect(service.deletePerson(10)).rejects.toMatchObject({
+        response: {
+          code: 'PERSON_IN_USE',
+          workflows: [{ id: '7', name: '资产审批' }],
+        },
+      });
+      expect(prisma.user.delete).not.toHaveBeenCalled();
+    });
+  });
+
   describe('findMany', () => {
     it('should return entities with itemCount', async () => {
       const findArgs = {

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

@@ -1,4 +1,9 @@
-import { Inject, Injectable } from '@nestjs/common';
+import {
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { Prisma, User } from '@prisma/client';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { PrismaService } from 'nestjs-prisma';
@@ -20,7 +25,21 @@ export class UserService {
   }
 
   async createOne(userCreateArgs: Prisma.UserCreateArgs) {
-    return await this.prisma.user.create(userCreateArgs);
+    try {
+      return await this.prisma.user.create(userCreateArgs);
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2002' &&
+        prismaErrorTargets(error).some((target) => target.includes('userid'))
+      ) {
+        throw new ConflictException({
+          code: 'USER_ALREADY_EXISTS',
+          message: '该人员已存在，无需重复添加',
+        });
+      }
+      throw error;
+    }
   }
 
   async createMany(data: Prisma.UserCreateManyArgs['data']) {
@@ -69,6 +88,94 @@ export class UserService {
     return { count: 1 };
   }
 
+  async deletePerson(id: number) {
+    const person = await this.prisma.user.findUnique({
+      where: { id },
+      select: {
+        userid: true,
+        roles: true,
+        groupMemberships: {
+          select: { group: { select: { code: true, name: true } } },
+        },
+      },
+    });
+    if (!person) throw new NotFoundException('人员不存在');
+
+    const [workflows, activeApprovalCount] = await Promise.all([
+      this.prisma.workflow.findMany({
+        select: {
+          id: true,
+          name: true,
+          dsl: true,
+          versions: { select: { dsl: true } },
+        },
+      }),
+      this.prisma.approvalCandidate.count({
+        where: {
+          principalType: 'USER',
+          principalRef: person.userid,
+          invalidatedAt: null,
+          request: { status: { in: ['PENDING', 'BLOCKED'] } },
+        },
+      }),
+    ]);
+    const roles = assignedRoles(person.roles);
+    const referencedWorkflows = workflows
+      .filter(
+        (workflow) =>
+          workflowDslReferencesUser(workflow.dsl, person.userid) ||
+          workflow.versions.some((version) =>
+            workflowDslReferencesUser(version.dsl, person.userid),
+          ),
+      )
+      .map((workflow) => ({ id: String(workflow.id), name: workflow.name }));
+    const groups = person.groupMemberships.map(({ group }) => group);
+    const reasons = [
+      ...(roles.length ? [`已授予角色：${roles.join('、')}`] : []),
+      ...(groups.length
+        ? [`已加入人员组：${groups.map((group) => group.name).join('、')}`]
+        : []),
+      ...(referencedWorkflows.length
+        ? [
+            `被 Workflow 引用：${referencedWorkflows
+              .map((workflow) => workflow.name)
+              .join('、')}`,
+          ]
+        : []),
+      ...(activeApprovalCount
+        ? [`仍有 ${activeApprovalCount} 个待处理审批`]
+        : []),
+    ];
+
+    if (reasons.length) {
+      throw new ConflictException({
+        code: 'PERSON_IN_USE',
+        message: `无法删除该人员：${reasons.join('；')}`,
+        reasons,
+        roles,
+        groups,
+        workflows: referencedWorkflows,
+        activeApprovalCount,
+      });
+    }
+
+    try {
+      await this.prisma.user.delete({ where: { id } });
+      return { count: 1 };
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2003'
+      ) {
+        throw new ConflictException({
+          code: 'PERSON_IN_USE',
+          message: '该人员刚被其他数据引用，请刷新后重试',
+        });
+      }
+      throw error;
+    }
+  }
+
   async count(userCountArgs?: Prisma.UserCountArgs) {
     return await this.prisma.user.count(userCountArgs);
   }
@@ -102,3 +209,44 @@ export class UserService {
     return key.substring(0, 8) + '****';
   }
 }
+
+function prismaErrorTargets(
+  error: Prisma.PrismaClientKnownRequestError,
+): string[] {
+  const target = error.meta?.target;
+  if (Array.isArray(target)) return target.map(String);
+  return target == null ? [] : [String(target)];
+}
+
+function assignedRoles(value: string): string[] {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed)
+      ? parsed.map(String).filter((role) => role.trim())
+      : value.trim()
+      ? [value]
+      : [];
+  } catch {
+    return value.trim() ? [value] : [];
+  }
+}
+
+function workflowDslReferencesUser(
+  value: Prisma.JsonValue | null,
+  userid: string,
+): boolean {
+  if (Array.isArray(value))
+    return value.some((item) => workflowDslReferencesUser(item, userid));
+  if (!value || typeof value !== 'object') return false;
+
+  const record = value as Record<string, Prisma.JsonValue>;
+  const refs = Array.isArray(record.refs) ? record.refs.map(String) : [];
+  if (
+    refs.includes(userid) &&
+    (record.source === 'STATIC' || record.provider === 'USER')
+  )
+    return true;
+  return Object.values(record).some((item) =>
+    workflowDslReferencesUser(item, userid),
+  );
+}

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

@@ -2,6 +2,7 @@ import { ACGuard } from '@gadmin2n/nest-common';
 import {
   Body,
   Controller,
+  Delete,
   Get,
   Param,
   Patch,
@@ -19,6 +20,7 @@ import {
 } from '../subjectProvider/actor-context.util';
 import {
   CreateUserGroupDto,
+  DeleteUserGroupDto,
   ReplaceUserGroupMembersDto,
   SetUserGroupActiveDto,
   UpdateUserGroupDto,
@@ -35,7 +37,7 @@ export class UserGroupController {
   @Get()
   @UseRoles({ resource: 'userGroup:read', action: 'read', possession: 'any' })
   search(@Query() query: UserGroupSearchDto) {
-    return this.service.search(query.q ?? '');
+    return this.service.search(query.q ?? '', query.includeInactive ?? false);
   }
 
   @Get(':code/preview')
@@ -116,4 +118,14 @@ export class UserGroupController {
       actorContextFromRequest(request),
     );
   }
+
+  @Delete(':code')
+  @UseRoles({
+    resource: 'userGroup:create',
+    action: 'delete',
+    possession: 'any',
+  })
+  remove(@Param('code') code: string, @Query() query: DeleteUserGroupDto) {
+    return this.service.deleteGroup(code, query.expectedRevision);
+  }
 }

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

@@ -1,4 +1,4 @@
-import { Type } from 'class-transformer';
+import { Transform, Type } from 'class-transformer';
 import {
   ArrayUnique,
   IsArray,
@@ -84,8 +84,20 @@ export class SetUserGroupActiveDto {
   isActive!: boolean;
 }
 
+export class DeleteUserGroupDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  expectedRevision!: number;
+}
+
 export class UserGroupSearchDto {
   @IsOptional()
   @IsString()
   q?: string;
+
+  @IsOptional()
+  @Transform(({ value }) => value === true || value === 'true')
+  @IsBoolean()
+  includeInactive?: boolean;
 }