@gadmin2n/schematics 0.0.139 → 0.0.140

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

@@ -0,0 +1,161 @@
+import { UserGroupService } from './user-group.service';
+
+const group = {
+  id: BigInt(1),
+  code: 'finance',
+  name: 'Finance',
+  description: null,
+  revision: 4,
+  isActive: true,
+  creator: 'admin',
+  createdAt: new Date(),
+  updatedAt: new Date(),
+};
+const actor = { userId: 'admin' };
+
+function createHarness() {
+  const tx = {
+    userGroup: {
+      findUnique: jest.fn().mockResolvedValue(group),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+    },
+    user: { findMany: jest.fn() },
+    userGroupUser: {
+      findMany: jest.fn().mockResolvedValue([]),
+      deleteMany: jest.fn().mockResolvedValue({ count: 0 }),
+      createMany: jest.fn().mockResolvedValue({ count: 1 }),
+    },
+    userGroupChild: {
+      findMany: jest.fn().mockResolvedValue([]),
+      deleteMany: jest.fn().mockResolvedValue({ count: 0 }),
+      createMany: jest.fn().mockResolvedValue({ count: 1 }),
+    },
+  };
+  const prisma = {
+    ...tx,
+    $transaction: jest.fn((fn) => fn(tx)),
+  };
+  return {
+    tx,
+    service: new UserGroupService(prisma as never),
+  };
+}
+
+describe('UserGroupService', () => {
+  it('returns direct users and child groups for editing', async () => {
+    const { service, tx } = createHarness();
+    tx.userGroup.findUnique
+      .mockResolvedValueOnce({
+        ...group,
+        users: [{ userId: 'alice' }],
+        children: [{ childGroup: { code: 'finance-child' } }],
+      })
+      .mockResolvedValueOnce({ id: group.id, isActive: true });
+    tx.userGroup.findMany.mockResolvedValueOnce([]);
+
+    await expect(service.preview('finance')).resolves.toMatchObject({
+      directUserIds: ['alice'],
+      childGroupCodes: ['finance-child'],
+    });
+  });
+
+  it('replaces members and bumps revision', async () => {
+    const { service, tx } = createHarness();
+    tx.user.findMany.mockResolvedValue([{ userid: 'u1' }]);
+    tx.userGroup.findMany
+      .mockResolvedValueOnce([{ id: BigInt(2), code: 'child' }])
+      .mockResolvedValueOnce([{ id: BigInt(1) }, { id: BigInt(2) }]);
+
+    await service.replaceMembers(
+      'finance',
+      {
+        expectedRevision: 4,
+        userIds: ['u1', 'u1'],
+        childGroupCodes: ['child'],
+      },
+      actor,
+    );
+
+    expect(tx.userGroup.updateMany).toHaveBeenCalledWith({
+      where: { id: BigInt(1), revision: 4 },
+      data: { revision: 5 },
+    });
+  });
+
+  it('does not bump revision or emit when normalized members are unchanged', async () => {
+    const { service, tx } = createHarness();
+    tx.user.findMany.mockResolvedValue([{ userid: 'u1' }]);
+    tx.userGroup.findMany.mockResolvedValue([{ id: BigInt(2), code: 'child' }]);
+    tx.userGroupUser.findMany.mockResolvedValue([{ userId: 'u1' }]);
+    tx.userGroupChild.findMany.mockResolvedValue([
+      { childGroup: { code: 'child' } },
+    ]);
+
+    await service.replaceMembers(
+      'finance',
+      {
+        expectedRevision: 4,
+        userIds: ['u1', 'u1'],
+        childGroupCodes: ['child', 'child'],
+      },
+      actor,
+    );
+
+    expect(tx.userGroup.updateMany).not.toHaveBeenCalled();
+  });
+
+  it('rejects a direct or indirect cycle', async () => {
+    const { service, tx } = createHarness();
+    tx.user.findMany.mockResolvedValue([]);
+    tx.userGroup.findMany
+      .mockResolvedValueOnce([{ id: BigInt(1), code: 'finance' }])
+      .mockResolvedValueOnce([{ id: BigInt(1) }]);
+
+    await expect(
+      service.replaceMembers(
+        'finance',
+        {
+          expectedRevision: 4,
+          userIds: [],
+          childGroupCodes: ['finance'],
+        },
+        actor,
+      ),
+    ).rejects.toMatchObject({
+      response: { code: 'USER_GROUP_CYCLE' },
+    });
+  });
+
+  it('rejects inactive or missing direct users', async () => {
+    const { service, tx } = createHarness();
+    tx.user.findMany.mockResolvedValue([]);
+    tx.userGroup.findMany.mockResolvedValue([]);
+
+    await expect(
+      service.replaceMembers(
+        'finance',
+        {
+          expectedRevision: 4,
+          userIds: ['inactive'],
+          childGroupCodes: [],
+        },
+        actor,
+      ),
+    ).rejects.toMatchObject({
+      response: { code: 'USER_GROUP_MEMBER_INVALID' },
+    });
+  });
+
+  it('returns 409 when expectedRevision is stale', async () => {
+    const { service } = createHarness();
+    await expect(
+      service.updateGroup(
+        'finance',
+        { expectedRevision: 3, name: 'Finance 2' },
+        actor,
+      ),
+    ).rejects.toMatchObject({ status: 409 });
+  });
+});

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

@@ -0,0 +1,390 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { PrismaService } from 'nestjs-prisma';
+import { ActorContext } from '../subjectProvider/subject-provider.types';
+import {
+  CreateUserGroupDto,
+  ReplaceUserGroupMembersDto,
+  SetUserGroupActiveDto,
+  UpdateUserGroupDto,
+} from './user-group.dto';
+import {
+  UserGroupDomainError,
+  userGroupNotFound,
+  userGroupRevisionConflict,
+} from './user-group.errors';
+
+export const MAX_GROUP_DEPTH = 20;
+
+type Transaction = Prisma.TransactionClient;
+
+@Injectable()
+export class UserGroupService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  createGroup(input: CreateUserGroupDto, actor: ActorContext) {
+    const userIds = this.normalize(input.userIds ?? []);
+    const childCodes = this.normalize(input.childGroupCodes ?? []);
+    const creator = this.creatorFrom(actor);
+
+    return this.prisma.$transaction(async (tx) => {
+      const [users, children] = await Promise.all([
+        this.requireActiveUsers(tx, userIds),
+        this.requireActiveGroups(tx, childCodes),
+      ]);
+      const group = await tx.userGroup.create({
+        data: {
+          ...(input.code && { code: input.code.trim() }),
+          name: input.name.trim(),
+          description: input.description?.trim(),
+          creator,
+        },
+      });
+      await this.validateGraphReplacement(tx, group.id, children);
+      await this.insertMembers(tx, group.id, users, children, creator);
+      return group;
+    });
+  }
+
+  updateGroup(code: string, input: UpdateUserGroupDto, actor: ActorContext) {
+    return this.prisma.$transaction(async (tx) => {
+      const group = await this.findGroup(tx, code);
+      this.assertRevision(group.revision, input.expectedRevision);
+      const data = {
+        ...(input.name !== undefined && { name: input.name.trim() }),
+        ...(input.description !== undefined && {
+          description: input.description?.trim() ?? null,
+        }),
+      };
+      const changedFields = Object.keys(data).filter(
+        (field) => group[field as 'name' | 'description'] !== data[field],
+      );
+      if (changedFields.length === 0) return group;
+
+      const revision = group.revision + 1;
+      await this.optimisticUpdate(tx, group.id, group.revision, {
+        ...data,
+        revision,
+      });
+      return { ...group, ...data, revision };
+    });
+  }
+
+  replaceMembers(
+    code: string,
+    input: ReplaceUserGroupMembersDto,
+    actor: ActorContext,
+  ) {
+    const userIds = this.normalize(input.userIds);
+    const childCodes = this.normalize(input.childGroupCodes);
+    const creator = this.creatorFrom(actor);
+
+    return this.prisma.$transaction(async (tx) => {
+      const group = await this.findGroup(tx, code);
+      this.assertRevision(group.revision, input.expectedRevision);
+      const [users, children, currentUsers, currentChildren] =
+        await Promise.all([
+          this.requireActiveUsers(tx, userIds),
+          this.requireActiveGroups(tx, childCodes),
+          tx.userGroupUser.findMany({
+            where: { groupId: group.id },
+            select: { userId: true },
+          }),
+          tx.userGroupChild.findMany({
+            where: { parentGroupId: group.id },
+            select: { childGroup: { select: { code: true } } },
+          }),
+        ]);
+
+      if (
+        this.same(
+          userIds,
+          currentUsers.map((item) => item.userId),
+        ) &&
+        this.same(
+          childCodes,
+          currentChildren.map((item) => item.childGroup.code),
+        )
+      ) {
+        return group;
+      }
+
+      await this.validateGraphReplacement(tx, group.id, children);
+      const revision = group.revision + 1;
+      await this.optimisticUpdate(tx, group.id, group.revision, { revision });
+      await Promise.all([
+        tx.userGroupUser.deleteMany({ where: { groupId: group.id } }),
+        tx.userGroupChild.deleteMany({
+          where: { parentGroupId: group.id },
+        }),
+      ]);
+      await this.insertMembers(tx, group.id, users, children, creator);
+      return { ...group, revision };
+    });
+  }
+
+  setActive(code: string, input: SetUserGroupActiveDto, actor: ActorContext) {
+    return this.prisma.$transaction(async (tx) => {
+      const group = await this.findGroup(tx, code);
+      this.assertRevision(group.revision, input.expectedRevision);
+      if (group.isActive === input.isActive) return group;
+
+      const revision = group.revision + 1;
+      await this.optimisticUpdate(tx, group.id, group.revision, {
+        isActive: input.isActive,
+        revision,
+      });
+      return { ...group, isActive: input.isActive, revision };
+    });
+  }
+
+  search(query: string) {
+    const q = query.trim();
+    return this.prisma.userGroup.findMany({
+      where: {
+        isActive: true,
+        ...(q && {
+          OR: [
+            { code: { contains: q, mode: 'insensitive' } },
+            { name: { contains: q, mode: 'insensitive' } },
+          ],
+        }),
+      },
+      orderBy: [{ name: 'asc' }, { code: 'asc' }],
+      select: {
+        code: true,
+        name: true,
+        description: true,
+        revision: true,
+      },
+      take: 50,
+    });
+  }
+
+  async preview(code: string) {
+    const group = await this.prisma.userGroup.findUnique({
+      where: { code },
+      select: {
+        code: true,
+        name: true,
+        description: true,
+        revision: true,
+        isActive: true,
+        users: {
+          select: { userId: true },
+          orderBy: { userId: 'asc' },
+        },
+        children: {
+          select: { childGroup: { select: { code: true } } },
+        },
+      },
+    });
+    if (!group) throw userGroupNotFound(code);
+    const users = await this.resolveUsers(code);
+    return {
+      code: group.code,
+      name: group.name,
+      description: group.description,
+      revision: group.revision,
+      isActive: group.isActive,
+      directUserIds: group.users.map((item) => item.userId),
+      childGroupCodes: group.children
+        .map((item) => item.childGroup.code)
+        .sort(),
+      resolvedUserCount: users.length,
+      users,
+    };
+  }
+
+  async resolveUsers(code: string) {
+    const root = await this.prisma.userGroup.findUnique({
+      where: { code },
+      select: { id: true, isActive: true },
+    });
+    if (!root) throw userGroupNotFound(code);
+    if (!root.isActive) return [];
+
+    const visited = new Set<bigint>();
+    const users = new Map<
+      string,
+      { userid: string; username: string | null }
+    >();
+    let level = [root.id];
+    let depth = 0;
+    while (level.length > 0) {
+      if (depth > MAX_GROUP_DEPTH) this.throwDepth();
+      const ids = level.filter((id) => !visited.has(id));
+      ids.forEach((id) => visited.add(id));
+      if (ids.length === 0) break;
+      const groups = await this.prisma.userGroup.findMany({
+        where: { id: { in: ids }, isActive: true },
+        select: {
+          users: {
+            where: { user: { isActive: true } },
+            select: {
+              user: { select: { userid: true, username: true } },
+            },
+          },
+          children: {
+            where: { childGroup: { isActive: true } },
+            select: { childGroupId: true },
+          },
+        },
+      });
+      level = [];
+      for (const group of groups) {
+        group.users.forEach(({ user }) => users.set(user.userid, user));
+        level.push(...group.children.map((child) => child.childGroupId));
+      }
+      depth += 1;
+    }
+    return [...users.values()].sort((a, b) => a.userid.localeCompare(b.userid));
+  }
+
+  private async findGroup(tx: Transaction, code: string) {
+    const group = await tx.userGroup.findUnique({ where: { code } });
+    if (!group) throw userGroupNotFound(code);
+    return group;
+  }
+
+  private assertRevision(actual: number, expected: number): void {
+    if (actual !== expected) throw userGroupRevisionConflict();
+  }
+
+  private async optimisticUpdate(
+    tx: Transaction,
+    id: bigint,
+    revision: number,
+    data: Prisma.UserGroupUpdateManyMutationInput,
+  ) {
+    const result = await tx.userGroup.updateMany({
+      where: { id, revision },
+      data,
+    });
+    if (result.count !== 1) throw userGroupRevisionConflict();
+  }
+
+  private async requireActiveUsers(tx: Transaction, userIds: string[]) {
+    if (userIds.length === 0) return [];
+    const users = await tx.user.findMany({
+      where: { userid: { in: userIds }, isActive: true },
+      select: { userid: true },
+    });
+    if (users.length !== userIds.length) {
+      throw new UserGroupDomainError(
+        'USER_GROUP_MEMBER_INVALID',
+        'Every direct user must exist and be active',
+      );
+    }
+    return users;
+  }
+
+  private async requireActiveGroups(tx: Transaction, codes: string[]) {
+    if (codes.length === 0) return [];
+    const groups = await tx.userGroup.findMany({
+      where: { code: { in: codes }, isActive: true },
+      select: { id: true, code: true },
+    });
+    if (groups.length !== codes.length) {
+      throw new UserGroupDomainError(
+        'USER_GROUP_MEMBER_INVALID',
+        'Every child group must exist and be active',
+      );
+    }
+    return groups;
+  }
+
+  private async validateGraphReplacement(
+    tx: Transaction,
+    parentId: bigint,
+    children: { id: bigint }[],
+  ) {
+    const [groups, edges] = await Promise.all([
+      tx.userGroup.findMany({
+        where: { isActive: true },
+        select: { id: true },
+      }),
+      tx.userGroupChild.findMany({
+        where: {
+          parentGroup: { isActive: true },
+          childGroup: { isActive: true },
+        },
+        select: { parentGroupId: true, childGroupId: true },
+      }),
+    ]);
+    const graph = new Map<bigint, bigint[]>();
+    groups.forEach((group) => graph.set(group.id, []));
+    edges.forEach((edge) => {
+      if (edge.parentGroupId !== parentId) {
+        graph.get(edge.parentGroupId)?.push(edge.childGroupId);
+      }
+    });
+    graph.set(
+      parentId,
+      children.map((child) => child.id),
+    );
+
+    const visit = (id: bigint, path: Set<bigint>, depth: number): void => {
+      if (path.has(id)) {
+        throw new UserGroupDomainError(
+          'USER_GROUP_CYCLE',
+          'Nested user groups cannot contain a cycle',
+        );
+      }
+      if (depth > MAX_GROUP_DEPTH) this.throwDepth();
+      const nextPath = new Set(path).add(id);
+      for (const child of graph.get(id) ?? []) {
+        visit(child, nextPath, depth + 1);
+      }
+    };
+    groups.forEach((group) => visit(group.id, new Set(), 0));
+  }
+
+  private throwDepth(): never {
+    throw new UserGroupDomainError(
+      'USER_GROUP_DEPTH_EXCEEDED',
+      `User group nesting cannot exceed ${MAX_GROUP_DEPTH}`,
+    );
+  }
+
+  private async insertMembers(
+    tx: Transaction,
+    groupId: bigint,
+    users: { userid: string }[],
+    children: { id: bigint }[],
+    creator: string,
+  ) {
+    if (users.length > 0) {
+      await tx.userGroupUser.createMany({
+        data: users.map((user) => ({ groupId, userId: user.userid, creator })),
+      });
+    }
+    if (children.length > 0) {
+      await tx.userGroupChild.createMany({
+        data: children.map((child) => ({
+          parentGroupId: groupId,
+          childGroupId: child.id,
+          creator,
+        })),
+      });
+    }
+  }
+
+  private creatorFrom(actor: ActorContext): string {
+    return actor.username ?? actor.userId;
+  }
+
+  private normalize(values: string[]): string[] {
+    return [
+      ...new Set(values.map((value) => value.trim()).filter(Boolean)),
+    ].sort();
+  }
+
+  private same(left: string[], right: string[]): boolean {
+    const sortedRight = [...right].sort();
+    return (
+      left.length === sortedRight.length &&
+      left.every((value, index) => value === sortedRight[index])
+    );
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { UserGroupController } from './user-group.controller';
+import { UserGroupService } from './user-group.service';
+
+@Module({
+  controllers: [UserGroupController],
+  providers: [UserGroupService],
+  exports: [UserGroupService],
+})
+export class UserGroupModule {}

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

@@ -202,4 +202,21 @@ describe('validateDslGraph', () => {
       }
     });
   });
+
+  it('does not treat a CALL/RETURN pair as a main-flow cycle', () => {
+    expect(() =>
+      validateDslGraph({
+        nodes: [
+          { id: 'trigger', type: 'manual_trigger' },
+          { id: 'approval', type: 'human_approval' },
+          { id: 'lookup', type: 'http_request' },
+        ],
+        edges: [
+          { source: 'trigger', target: 'approval', kind: 'FLOW' },
+          { source: 'approval', target: 'lookup', kind: 'CALL' },
+          { source: 'lookup', target: 'approval', kind: 'RETURN' },
+        ],
+      }),
+    ).not.toThrow();
+  });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/dsl-validate.util.ts

@@ -18,7 +18,11 @@
  */
 export interface DslGraphLike {
   nodes?: Array<{ id?: string; type?: string }>;
-  edges?: Array<{ source?: string; target?: string }>;
+  edges?: Array<{
+    source?: string;
+    target?: string;
+    kind?: 'FLOW' | 'DATA' | 'CALL' | 'RETURN';
+  }>;
 }
 
 export function validateDslGraph(dsl: unknown): void {
@@ -82,7 +86,9 @@ export function validateDslGraph(dsl: unknown): void {
     indegree.set(id, 0);
     adj.set(id, []);
   }
-  for (const e of g.edges) {
+  for (const e of g.edges.filter(
+    (edge) => !edge.kind || edge.kind === 'FLOW',
+  )) {
     indegree.set(e.target!, indegree.get(e.target!)! + 1);
     adj.get(e.source!)!.push(e.target!);
   }

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

@@ -0,0 +1,93 @@
+export type ParameterBinding =
+  | {
+      source: 'INPUT' | 'WORKFLOW' | 'SYSTEM';
+      path: string;
+    }
+  | {
+      source: 'FIXED';
+      valueType: 'STRING' | 'NUMBER' | 'BOOLEAN' | 'JSON';
+      value: string;
+    };
+
+export function validateParameterBinding(
+  value: unknown,
+): value is ParameterBinding {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const binding = value as Record<string, unknown>;
+  if (
+    binding.source === 'INPUT' ||
+    binding.source === 'WORKFLOW' ||
+    binding.source === 'SYSTEM'
+  )
+    return typeof binding.path === 'string' && Boolean(binding.path.trim());
+  if (binding.source !== 'FIXED') return false;
+  if (
+    !['STRING', 'NUMBER', 'BOOLEAN', 'JSON'].includes(
+      String(binding.valueType),
+    ) ||
+    typeof binding.value !== 'string'
+  )
+    return false;
+  if (binding.valueType === 'NUMBER')
+    return (
+      binding.value.trim() !== '' && Number.isFinite(Number(binding.value))
+    );
+  if (binding.valueType === 'BOOLEAN')
+    return binding.value === 'true' || binding.value === 'false';
+  if (binding.valueType === 'JSON') {
+    try {
+      JSON.parse(binding.value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function resolveParameterBinding(
+  binding: ParameterBinding,
+  input: unknown,
+  workflow: Record<string, unknown>,
+  system: Record<string, unknown> = {},
+): unknown {
+  if (binding.source === 'FIXED') {
+    if (binding.valueType === 'STRING') return binding.value;
+    if (binding.valueType === 'NUMBER') return Number(binding.value);
+    if (binding.valueType === 'BOOLEAN') return binding.value === 'true';
+    return JSON.parse(binding.value);
+  }
+
+  const sourceName =
+    binding.source === 'INPUT'
+      ? 'input'
+      : binding.source === 'WORKFLOW'
+      ? 'workflow'
+      : 'system';
+  const root =
+    binding.source === 'INPUT'
+      ? input
+      : binding.source === 'WORKFLOW'
+      ? workflow
+      : system;
+  const value = readPath(root, binding.path);
+  if (value === undefined)
+    throw new Error(
+      `HTTP_BINDING_RESOLUTION_FAILED:${sourceName}.${binding.path}`,
+    );
+  return value;
+}
+
+function readPath(root: unknown, path: string): unknown {
+  let current = root;
+  for (const part of path.trim().split('.')) {
+    if (
+      !current ||
+      typeof current !== 'object' ||
+      !Object.prototype.hasOwnProperty.call(current, part)
+    )
+      return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}