@gadmin2n/schematics 0.0.139 → 0.0.140

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

@@ -0,0 +1,115 @@
+import { Injectable } from '@nestjs/common';
+import {
+  SubjectProviderDuplicateError,
+  SubjectProviderError,
+  SubjectProviderNotFoundError,
+  SubjectProviderUnavailableError,
+} from './subject-provider.errors';
+import {
+  ActorContext,
+  FrozenSubjectProviderDescriptor,
+  SubjectProvider,
+  SubjectProviderDescriptor,
+} from './subject-provider.types';
+
+@Injectable()
+export class SubjectProviderRegistry {
+  private readonly providers = new Map<string, SubjectProvider>();
+
+  register(provider: SubjectProvider): void {
+    const key = provider.key;
+    if (typeof key !== 'string' || key.trim().length === 0) {
+      throw new SubjectProviderUnavailableError(
+        '',
+        'Subject provider key must not be empty',
+      );
+    }
+    if (key !== key.trim()) {
+      throw new SubjectProviderUnavailableError(
+        key,
+        'Subject provider key must not contain surrounding whitespace',
+      );
+    }
+    if (this.providers.has(key)) {
+      throw new SubjectProviderDuplicateError(key);
+    }
+
+    this.providers.set(key, provider);
+  }
+
+  get(key: string): SubjectProvider {
+    const provider = this.providers.get(key);
+    if (!provider) {
+      throw new SubjectProviderNotFoundError(key);
+    }
+    return provider;
+  }
+
+  listDescriptors(
+    actor: ActorContext,
+  ): readonly FrozenSubjectProviderDescriptor[] {
+    const descriptors = Array.from(this.providers.values()).map((provider) =>
+      this.getFrozenDescriptor(provider, actor),
+    );
+
+    descriptors.sort((left, right) => {
+      if (left.label < right.label) return -1;
+      if (left.label > right.label) return 1;
+      if (left.key < right.key) return -1;
+      if (left.key > right.key) return 1;
+      return 0;
+    });
+
+    return Object.freeze(descriptors);
+  }
+
+  private getFrozenDescriptor(
+    provider: SubjectProvider,
+    actor: ActorContext,
+  ): FrozenSubjectProviderDescriptor {
+    let descriptor: SubjectProviderDescriptor;
+    try {
+      descriptor = provider.descriptor(actor);
+    } catch (error) {
+      if (error instanceof SubjectProviderError) throw error;
+      throw new SubjectProviderUnavailableError(provider.key);
+    }
+
+    if (
+      descriptor == null ||
+      descriptor.key !== provider.key ||
+      typeof descriptor.label !== 'string' ||
+      descriptor.label.trim().length === 0
+    ) {
+      throw new SubjectProviderUnavailableError(provider.key);
+    }
+
+    return cloneAndFreeze(descriptor);
+  }
+}
+
+function cloneAndFreeze<T>(value: T): FrozenValue<T> {
+  if (Array.isArray(value)) {
+    return Object.freeze(
+      value.map((item) => cloneAndFreeze(item)),
+    ) as FrozenValue<T>;
+  }
+
+  if (value !== null && typeof value === 'object') {
+    const clone: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value)) {
+      clone[key] = cloneAndFreeze(item);
+    }
+    return Object.freeze(clone) as FrozenValue<T>;
+  }
+
+  return value as FrozenValue<T>;
+}
+
+type FrozenValue<T> = T extends SubjectProviderDescriptor
+  ? FrozenSubjectProviderDescriptor
+  : T extends readonly (infer U)[]
+  ? readonly FrozenValue<U>[]
+  : T extends object
+  ? { readonly [K in keyof T]: FrozenValue<T[K]> }
+  : T;

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

@@ -0,0 +1,97 @@
+export interface ActorContext {
+  readonly userId: string;
+  readonly username?: string;
+  readonly roles?: readonly string[];
+  readonly permissions?: readonly string[];
+}
+
+export interface SubjectProviderCapabilities {
+  search: boolean;
+  preview: boolean;
+  inlineCreate: boolean;
+  edit: boolean;
+  emitsChanges: boolean;
+}
+
+export interface SubjectProviderDescriptor {
+  key: string;
+  label: string;
+  referenceFormat: 'STRING';
+  principalType: 'USER';
+  capabilities: SubjectProviderCapabilities;
+  createSchema?: Record<string, unknown>;
+  createUiSchema?: Record<string, unknown>;
+}
+
+export interface SubjectResource {
+  ref: string;
+  label: string;
+  description?: string;
+  active?: boolean;
+  revision?: number;
+  metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface ProviderValidationIssue {
+  ref?: string;
+  code: string;
+  message: string;
+}
+
+export interface ProviderValidationResult {
+  valid: boolean;
+  issues?: readonly ProviderValidationIssue[];
+}
+
+export interface SubjectPreviewItem extends SubjectResource {
+  principals?: readonly ResolvedPrincipal[];
+}
+
+export interface SubjectPreview {
+  items: readonly SubjectPreviewItem[];
+  warnings?: readonly string[];
+}
+
+export interface ResolveContext {
+  readonly actor?: ActorContext;
+  readonly executionId?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface ResolvedPrincipal {
+  principalType: 'USER';
+  principalRef: string;
+  displayName?: string;
+  sourceRefs: readonly string[];
+  metadata?: Readonly<Record<string, unknown>>;
+}
+
+export interface SubjectProvider {
+  readonly key: string;
+  descriptor(actor: ActorContext): SubjectProviderDescriptor;
+  search(query: string, actor: ActorContext): Promise<SubjectResource[]>;
+  create(
+    input: Record<string, unknown>,
+    actor: ActorContext,
+  ): Promise<SubjectResource>;
+  validate(
+    refs: string[],
+    actor: ActorContext,
+  ): Promise<ProviderValidationResult>;
+  preview(refs: string[], actor: ActorContext): Promise<SubjectPreview>;
+  resolve(
+    refs: string[],
+    context: ResolveContext,
+  ): Promise<ResolvedPrincipal[]>;
+}
+
+export type DeepReadonly<T> = T extends (...args: any[]) => unknown
+  ? T
+  : T extends readonly (infer U)[]
+  ? readonly DeepReadonly<U>[]
+  : T extends object
+  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+  : T;
+
+export type FrozenSubjectProviderDescriptor =
+  DeepReadonly<SubjectProviderDescriptor>;

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

@@ -0,0 +1,34 @@
+import { Injectable, Module, OnModuleInit } from '@nestjs/common';
+import { UserModule } from '../user/user.module';
+import { UserGroupModule } from '../userGroup/userGroup.module';
+import { UserGroupProvider } from './providers/user-group.provider';
+import { UserProvider } from './providers/user.provider';
+import { SubjectProviderController } from './subject-provider.controller';
+import { SubjectProviderRegistry } from './subject-provider.registry';
+
+@Injectable()
+class SubjectProviderRegistrar implements OnModuleInit {
+  constructor(
+    private readonly registry: SubjectProviderRegistry,
+    private readonly user: UserProvider,
+    private readonly userGroup: UserGroupProvider,
+  ) {}
+
+  onModuleInit(): void {
+    this.registry.register(this.user);
+    this.registry.register(this.userGroup);
+  }
+}
+
+@Module({
+  imports: [UserModule, UserGroupModule],
+  controllers: [SubjectProviderController],
+  providers: [
+    SubjectProviderRegistry,
+    UserProvider,
+    UserGroupProvider,
+    SubjectProviderRegistrar,
+  ],
+  exports: [SubjectProviderRegistry],
+})
+export class SubjectProviderModule {}

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

@@ -7,7 +7,11 @@ import { TemporalTenantConfigService } from './temporalTenantConfig.service';
 
 // Mock TemporalTenantConfigService：用空对象屏蔽真实 Service 的依赖（PrismaService 等），
 // 避免 NestJS 在测试模块编译时去解析 Service 的构造参数。
-const mockTemporalTenantConfigService = {};
+const mockTemporalTenantConfigService = {
+  createOne: jest.fn(),
+  findUnique: jest.fn(),
+  updateUnique: jest.fn(),
+};
 
 // Mock ConfigService
 const mockConfigService = {
@@ -25,8 +29,11 @@ const mockLogger = {
 
 describe('TemporalTenantConfigController', () => {
   let controller: TemporalTenantConfigController;
+  const originalFetch = global.fetch;
 
   beforeEach(async () => {
+    jest.clearAllMocks();
+
     const module: TestingModule = await Test.createTestingModule({
       controllers: [TemporalTenantConfigController],
       providers: [
@@ -48,7 +55,88 @@ describe('TemporalTenantConfigController', () => {
     );
   });
 
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  it('registers and persists the tenant runtime connection', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+    });
+    mockTemporalTenantConfigService.createOne.mockResolvedValue({
+      id: 1,
+    });
+
+    await controller.createOne(
+      {
+        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,
+      (value) => value,
+      { user: { username: 'admin' } } as any,
+    );
+
+    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(mockTemporalTenantConfigService.createOne).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        runtimeBaseUrl: 'http://gadmin-server:8000/api',
+        runtimeToken: '0123456789abcdef0123456789abcdef',
+      }),
+    });
+  });
+
+  it('updates the tenant runtime connection in shared Temporal', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+    });
+    mockTemporalTenantConfigService.findUnique.mockResolvedValue({
+      adminUrl: 'http://temporal.example:8081',
+      adminToken: 'admin-token',
+      namespace: 'gadmin-test',
+    });
+    mockTemporalTenantConfigService.updateUnique.mockResolvedValue({
+      id: 1,
+    });
+
+    await controller.updateUnique(
+      1,
+      {
+        runtimeBaseUrl: 'http://gadmin-server:8000/api',
+        runtimeToken: '0123456789abcdef0123456789abcdef',
+      },
+      (value) => value,
+    );
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'http://temporal.example:8081/admin/tenants/gadmin-test',
+      expect.objectContaining({
+        method: 'PATCH',
+        body: JSON.stringify({
+          runtimeBaseUrl: 'http://gadmin-server:8000/api',
+          runtimeToken: '0123456789abcdef0123456789abcdef',
+        }),
+      }),
+    );
+  });
 });

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

@@ -84,6 +84,8 @@ export class TemporalTenantConfigController {
         namespace: body.namespace,
         displayName: body.displayName,
         dbUrl: body.dbUrl,
+        runtimeBaseUrl: body.runtimeBaseUrl,
+        runtimeToken: body.runtimeToken,
       }),
     });
     if (!res.ok) {
@@ -175,6 +177,8 @@ export class TemporalTenantConfigController {
     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 (Object.keys(patchBody).length > 0) {
       const res = await fetch(

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

@@ -0,0 +1,119 @@
+import { ACGuard } from '@gadmin2n/nest-common';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { UseRoles } from 'nest-access-control';
+import {
+  actorContextFromRequest,
+  AuthenticatedActorRequest,
+} from '../subjectProvider/actor-context.util';
+import {
+  CreateUserGroupDto,
+  ReplaceUserGroupMembersDto,
+  SetUserGroupActiveDto,
+  UpdateUserGroupDto,
+  UserGroupSearchDto,
+} from './user-group.dto';
+import { UserGroupService } from './user-group.service';
+
+@ApiTags('user-groups')
+@UseGuards(ACGuard)
+@Controller('user-groups')
+export class UserGroupController {
+  constructor(private readonly service: UserGroupService) {}
+
+  @Get()
+  @UseRoles({ resource: 'userGroup:read', action: 'read', possession: 'any' })
+  search(@Query() query: UserGroupSearchDto) {
+    return this.service.search(query.q ?? '');
+  }
+
+  @Get(':code/preview')
+  @UseRoles({ resource: 'userGroup:read', action: 'read', possession: 'any' })
+  preview(@Param('code') code: string) {
+    return this.service.preview(code);
+  }
+
+  @Get(':code/users')
+  @UseRoles({ resource: 'userGroup:read', action: 'read', possession: 'any' })
+  resolveUsers(@Param('code') code: string) {
+    return this.service.resolveUsers(code);
+  }
+
+  @Post()
+  @UseRoles({
+    resource: 'userGroup:create',
+    action: 'create',
+    possession: 'any',
+  })
+  create(
+    @Body() input: CreateUserGroupDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return this.service.createGroup(input, actorContextFromRequest(request));
+  }
+
+  @Patch(':code')
+  @UseRoles({
+    resource: 'userGroup:create',
+    action: 'update',
+    possession: 'any',
+  })
+  update(
+    @Param('code') code: string,
+    @Body() input: UpdateUserGroupDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return this.service.updateGroup(
+      code,
+      input,
+      actorContextFromRequest(request),
+    );
+  }
+
+  @Put(':code/members')
+  @UseRoles({
+    resource: 'userGroup:create',
+    action: 'update',
+    possession: 'any',
+  })
+  replaceMembers(
+    @Param('code') code: string,
+    @Body() input: ReplaceUserGroupMembersDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return this.service.replaceMembers(
+      code,
+      input,
+      actorContextFromRequest(request),
+    );
+  }
+
+  @Patch(':code/active')
+  @UseRoles({
+    resource: 'userGroup:create',
+    action: 'update',
+    possession: 'any',
+  })
+  setActive(
+    @Param('code') code: string,
+    @Body() input: SetUserGroupActiveDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return this.service.setActive(
+      code,
+      input,
+      actorContextFromRequest(request),
+    );
+  }
+}

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

@@ -0,0 +1,91 @@
+import { Type } from 'class-transformer';
+import {
+  ArrayUnique,
+  IsArray,
+  IsBoolean,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+
+export class CreateUserGroupDto {
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(21)
+  code?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(128)
+  name!: string;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(512)
+  description?: string;
+
+  @IsOptional()
+  @IsArray()
+  @ArrayUnique()
+  @IsString({ each: true })
+  userIds?: string[];
+
+  @IsOptional()
+  @IsArray()
+  @ArrayUnique()
+  @IsString({ each: true })
+  childGroupCodes?: string[];
+}
+
+export class UpdateUserGroupDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  expectedRevision!: number;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(128)
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(512)
+  description?: string | null;
+}
+
+export class ReplaceUserGroupMembersDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  expectedRevision!: number;
+
+  @IsArray()
+  @IsString({ each: true })
+  userIds!: string[];
+
+  @IsArray()
+  @IsString({ each: true })
+  childGroupCodes!: string[];
+}
+
+export class SetUserGroupActiveDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  expectedRevision!: number;
+
+  @IsBoolean()
+  isActive!: boolean;
+}
+
+export class UserGroupSearchDto {
+  @IsOptional()
+  @IsString()
+  q?: string;
+}

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

@@ -0,0 +1,34 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export type UserGroupErrorCode =
+  | 'USER_GROUP_CYCLE'
+  | 'USER_GROUP_DEPTH_EXCEEDED'
+  | 'USER_GROUP_MEMBER_INVALID'
+  | 'USER_GROUP_REVISION_CONFLICT'
+  | 'USER_GROUP_NOT_FOUND';
+
+export class UserGroupDomainError extends HttpException {
+  constructor(
+    code: UserGroupErrorCode,
+    message: string,
+    status: HttpStatus = HttpStatus.BAD_REQUEST,
+  ) {
+    super({ code, message }, status);
+  }
+}
+
+export function userGroupNotFound(code: string): UserGroupDomainError {
+  return new UserGroupDomainError(
+    'USER_GROUP_NOT_FOUND',
+    `User group not found: ${code}`,
+    HttpStatus.NOT_FOUND,
+  );
+}
+
+export function userGroupRevisionConflict(): UserGroupDomainError {
+  return new UserGroupDomainError(
+    'USER_GROUP_REVISION_CONFLICT',
+    'User group has changed; refresh and retry',
+    HttpStatus.CONFLICT,
+  );
+}