@gadmin2n/schematics 0.0.87 → 0.0.89

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

@@ -1,18 +1,326 @@
+/// <reference types="jest" />
+import { ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+
+// Mock nestjs-prisma 模块
+jest.mock('nestjs-prisma', () => ({
+  PrismaService: jest.fn(),
+}));
+
+import { PrismaService } from 'nestjs-prisma';
 import { UserService } from './user.service';
 
+// Mock PrismaService
+const mockPrismaService = {
+  user: {
+    create: jest.fn(),
+    createMany: jest.fn(),
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    update: jest.fn(),
+    updateMany: jest.fn(),
+    delete: jest.fn(),
+    deleteMany: jest.fn(),
+    count: jest.fn(),
+    groupBy: jest.fn(),
+    aggregate: jest.fn(),
+  },
+};
+
+// Mock Logger
+const mockLogger = {
+  child: jest.fn().mockReturnThis(),
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
+// Mock ConfigService
+const mockConfigService = {
+  get: jest.fn(),
+};
+
 describe('UserService', () => {
   let service: UserService;
+  let prisma: typeof mockPrismaService;
 
   beforeEach(async () => {
+    // 每个测试前重置所有 mock
+    jest.clearAllMocks();
+
     const module: TestingModule = await Test.createTestingModule({
-      providers: [UserService],
+      providers: [
+        UserService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
     }).compile();
 
     service = module.get<UserService>(UserService);
+    prisma = mockPrismaService;
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('createOne', () => {
+    it('should create a single user record', async () => {
+      const createArgs = {
+        data: {
+          userid: 'test_userid',
+          username: 'test_username',
+          roles: '[]',
+        },
+      } as any;
+      const expectedResult = { id: 1, ...createArgs.data };
+
+      prisma.user.create.mockResolvedValue(expectedResult);
+
+      const result = await service.createOne(createArgs);
+
+      expect(prisma.user.create).toHaveBeenCalledWith(createArgs);
+      expect(prisma.user.create).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should throw error when create fails', async () => {
+      const createArgs = {
+        data: {
+          userid: 'test_userid',
+          username: 'test_username',
+          roles: '[]',
+        },
+      } as any;
+      const error = new Error('Database connection failed');
+
+      prisma.user.create.mockRejectedValue(error);
+
+      await expect(service.createOne(createArgs)).rejects.toThrow(
+        'Database connection failed',
+      );
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple user records with skipDuplicates', async () => {
+      const data = [
+        {
+          userid: 'test_userid',
+          username: 'test_username',
+          roles: '[]',
+        },
+        {
+          userid: 'test_userid',
+          username: 'test_username',
+          roles: '[]',
+        },
+      ] as any;
+      const expectedResult = { count: 2 };
+
+      prisma.user.createMany.mockResolvedValue(expectedResult);
+
+      const result = await service.createMany(data);
+
+      expect(prisma.user.createMany).toHaveBeenCalledWith({
+        data,
+        skipDuplicates: true,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('findMany', () => {
+    it('should return entities with itemCount', async () => {
+      const findArgs = {
+        where: {},
+        take: 10,
+        skip: 0,
+      } as any;
+      const mockEntities = [{ id: 1 }, { id: 2 }];
+
+      prisma.user.count.mockResolvedValue(2);
+      prisma.user.findMany.mockResolvedValue(mockEntities);
+
+      const result = await service.findMany(findArgs);
+
+      expect(prisma.user.count).toHaveBeenCalledWith({ where: findArgs.where });
+      expect(prisma.user.findMany).toHaveBeenCalledWith(findArgs);
+      expect(result).toEqual({
+        itemCount: 2,
+        entities: mockEntities,
+      });
+    });
+
+    it('should return empty result when no records found', async () => {
+      const findArgs = { where: {} } as any;
+
+      prisma.user.count.mockResolvedValue(0);
+      prisma.user.findMany.mockResolvedValue([]);
+
+      const result = await service.findMany(findArgs);
+
+      expect(result).toEqual({ itemCount: 0, entities: [] });
+    });
+  });
+
+  describe('findUnique', () => {
+    it('should find a single user record by id', async () => {
+      const id = 1;
+      const select = { id: true };
+      const expectedResult = { id: 1 };
+
+      prisma.user.findUnique.mockResolvedValue(expectedResult);
+
+      const result = await service.findUnique(id, select);
+
+      expect(prisma.user.findUnique).toHaveBeenCalledWith({
+        where: { id },
+        select,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should return null when record not found', async () => {
+      prisma.user.findUnique.mockResolvedValue(null);
+
+      const result = await service.findUnique(1, { id: true });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUnique', () => {
+    it('should update a single user record', async () => {
+      const id = 1;
+      const data = {
+        userid: 'test_userid',
+        username: 'test_username',
+        roles: '[]',
+      } as any;
+      const expectedResult = { id: 1, ...data };
+
+      prisma.user.update.mockResolvedValue(expectedResult);
+
+      const result = await service.updateUnique(id, data);
+
+      expect(prisma.user.update).toHaveBeenCalledWith({
+        where: { id },
+        data,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('updateMany', () => {
+    it('should update multiple user records', async () => {
+      const updateArgs = {
+        where: {},
+        data: {
+          userid: 'test_userid',
+          username: 'test_username',
+          roles: '[]',
+        },
+      } as any;
+      const expectedResult = { count: 5 };
+
+      prisma.user.updateMany.mockResolvedValue(expectedResult);
+
+      const result = await service.updateMany(updateArgs);
+
+      expect(prisma.user.updateMany).toHaveBeenCalledWith(updateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('deleteUnique', () => {
+    it('should delete a single user record and return count', async () => {
+      const id = 1;
+
+      prisma.user.delete.mockResolvedValue({ id: 1 });
+
+      const result = await service.deleteUnique(id);
+
+      expect(prisma.user.delete).toHaveBeenCalledWith({ where: { id } });
+      expect(result).toEqual({ count: 1 });
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should delete multiple user records', async () => {
+      const deleteArgs = { where: {} } as any;
+      const expectedResult = { count: 3 };
+
+      prisma.user.deleteMany.mockResolvedValue(expectedResult);
+
+      const result = await service.deleteMany(deleteArgs);
+
+      expect(prisma.user.deleteMany).toHaveBeenCalledWith(deleteArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('count', () => {
+    it('should count user records with filter', async () => {
+      const countArgs = { where: {} } as any;
+
+      prisma.user.count.mockResolvedValue(10);
+
+      const result = await service.count(countArgs);
+
+      expect(prisma.user.count).toHaveBeenCalledWith(countArgs);
+      expect(result).toBe(10);
+    });
+
+    it('should count all records when no filter provided', async () => {
+      prisma.user.count.mockResolvedValue(100);
+
+      const result = await service.count();
+
+      expect(prisma.user.count).toHaveBeenCalledWith(undefined);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group user records by specified field', async () => {
+      const groupByArgs = {
+        by: ['id'],
+        _count: { id: true },
+      } as any;
+      const expectedResult = [{ id: 1, _count: { id: 50 } }];
+
+      prisma.user.groupBy.mockResolvedValue(expectedResult);
+
+      const result = await service.groupBy(groupByArgs);
+
+      expect(prisma.user.groupBy).toHaveBeenCalledWith(groupByArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('aggregate', () => {
+    it('should aggregate user records', async () => {
+      const aggregateArgs = {
+        _count: true,
+        _max: { id: true },
+        _min: { id: true },
+      } as any;
+      const expectedResult = {
+        _count: 100,
+        _max: { id: 1 },
+        _min: { id: 1 },
+      };
+
+      prisma.user.aggregate.mockResolvedValue(expectedResult);
+
+      const result = await service.aggregate(aggregateArgs);
+
+      expect(prisma.user.aggregate).toHaveBeenCalledWith(aggregateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
 });

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

@@ -0,0 +1,205 @@
+import { validateDslGraph } from './dsl-validate.util';
+
+describe('validateDslGraph', () => {
+  const validDsl = {
+    nodes: [
+      { id: 't1', type: 'manual_trigger' },
+      { id: 'n1', type: 'http_request' },
+      { id: 'n2', type: 'send_notification' },
+    ],
+    edges: [
+      { source: 't1', target: 'n1' },
+      { source: 'n1', target: 'n2' },
+    ],
+  };
+
+  describe('valid input', () => {
+    it('accepts a simple linear DAG', () => {
+      expect(() => validateDslGraph(validDsl)).not.toThrow();
+    });
+
+    it('accepts a diamond DAG', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [
+            { id: 't1', type: 'manual_trigger' },
+            { id: 'a', type: 'http_request' },
+            { id: 'b', type: 'http_request' },
+            { id: 'c', type: 'send_notification' },
+          ],
+          edges: [
+            { source: 't1', target: 'a' },
+            { source: 't1', target: 'b' },
+            { source: 'a', target: 'c' },
+            { source: 'b', target: 'c' },
+          ],
+        }),
+      ).not.toThrow();
+    });
+
+    it('accepts a trigger with no successors', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [{ id: 't1', type: 'cron_trigger' }],
+          edges: [],
+        }),
+      ).not.toThrow();
+    });
+  });
+
+  describe('shape errors', () => {
+    it('rejects null', () => {
+      expect(() => validateDslGraph(null)).toThrow('DSL must be an object');
+    });
+
+    it('rejects missing nodes array', () => {
+      expect(() => validateDslGraph({ edges: [] })).toThrow(
+        'DSL.nodes must be an array',
+      );
+    });
+
+    it('rejects missing edges array', () => {
+      expect(() =>
+        validateDslGraph({ nodes: [{ id: 't1', type: 'manual_trigger' }] }),
+      ).toThrow('DSL.edges must be an array');
+    });
+
+    it('rejects empty nodes', () => {
+      expect(() => validateDslGraph({ nodes: [], edges: [] })).toThrow(
+        'at least one node',
+      );
+    });
+
+    it('rejects node without id', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [{ type: 'manual_trigger' }],
+          edges: [],
+        }),
+      ).toThrow('non-empty string id');
+    });
+
+    it('rejects duplicate node ids', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [
+            { id: 't1', type: 'manual_trigger' },
+            { id: 't1', type: 'http_request' },
+          ],
+          edges: [],
+        }),
+      ).toThrow('Duplicate node id');
+    });
+
+    it('rejects node without type', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [{ id: 't1' }],
+          edges: [],
+        }),
+      ).toThrow('non-empty string type');
+    });
+
+    it('rejects DSL with no trigger node', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [{ id: 'n1', type: 'http_request' }],
+          edges: [],
+        }),
+      ).toThrow('at least one *_trigger node');
+    });
+  });
+
+  describe('edge errors', () => {
+    it('rejects edge with unknown source', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [{ id: 't1', type: 'manual_trigger' }],
+          edges: [{ source: 'ghost', target: 't1' }],
+        }),
+      ).toThrow('unknown source');
+    });
+
+    it('rejects edge with unknown target', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [{ id: 't1', type: 'manual_trigger' }],
+          edges: [{ source: 't1', target: 'ghost' }],
+        }),
+      ).toThrow('unknown target');
+    });
+
+    it('rejects self-loop', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [
+            { id: 't1', type: 'manual_trigger' },
+            { id: 'a', type: 'http_request' },
+          ],
+          edges: [
+            { source: 't1', target: 'a' },
+            { source: 'a', target: 'a' },
+          ],
+        }),
+      ).toThrow('Self-loop');
+    });
+  });
+
+  describe('cycle detection', () => {
+    it('rejects a 2-node cycle', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [
+            { id: 't1', type: 'manual_trigger' },
+            { id: 'a', type: 'http_request' },
+            { id: 'b', type: 'http_request' },
+          ],
+          edges: [
+            { source: 't1', target: 'a' },
+            { source: 'a', target: 'b' },
+            { source: 'b', target: 'a' },
+          ],
+        }),
+      ).toThrow('cycle');
+    });
+
+    it('rejects a 3-node cycle', () => {
+      expect(() =>
+        validateDslGraph({
+          nodes: [
+            { id: 't1', type: 'manual_trigger' },
+            { id: 'a', type: 'http_request' },
+            { id: 'b', type: 'http_request' },
+            { id: 'c', type: 'http_request' },
+          ],
+          edges: [
+            { source: 't1', target: 'a' },
+            { source: 'a', target: 'b' },
+            { source: 'b', target: 'c' },
+            { source: 'c', target: 'a' },
+          ],
+        }),
+      ).toThrow('cycle');
+    });
+
+    it('error message lists nodes still in the cycle', () => {
+      try {
+        validateDslGraph({
+          nodes: [
+            { id: 't1', type: 'manual_trigger' },
+            { id: 'a', type: 'http_request' },
+            { id: 'b', type: 'http_request' },
+          ],
+          edges: [
+            { source: 't1', target: 'a' },
+            { source: 'a', target: 'b' },
+            { source: 'b', target: 'a' },
+          ],
+        });
+        fail('expected validation to throw');
+      } catch (err: any) {
+        expect(err.message).toMatch(/a|b/);
+      }
+    });
+  });
+});

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

@@ -0,0 +1,116 @@
+/**
+ * DSL graph structural validation.
+ *
+ * Used by WorkflowService.publish() to reject malformed or cyclic DSLs before
+ * they become a published version. The worker's executeGraph still has a runtime
+ * iteration cap as defense-in-depth, but with this validation in place the cap
+ * should never trip in practice.
+ *
+ * Validates:
+ * 1. nodes / edges are present and well-typed
+ * 2. every edge references existing nodes
+ * 3. node ids are unique
+ * 4. there is at least one trigger node
+ * 5. graph is a DAG (Kahn's algorithm — no cycles)
+ *
+ * Throws Error with a human-readable message on the first failure;
+ * caller should map to BadRequestException.
+ */
+export interface DslGraphLike {
+  nodes?: Array<{ id?: string; type?: string }>;
+  edges?: Array<{ source?: string; target?: string }>;
+}
+
+export function validateDslGraph(dsl: unknown): void {
+  if (!dsl || typeof dsl !== 'object') {
+    throw new Error('DSL must be an object');
+  }
+  const g = dsl as DslGraphLike;
+
+  if (!Array.isArray(g.nodes)) {
+    throw new Error('DSL.nodes must be an array');
+  }
+  if (!Array.isArray(g.edges)) {
+    throw new Error('DSL.edges must be an array');
+  }
+  if (g.nodes.length === 0) {
+    throw new Error('DSL must contain at least one node');
+  }
+
+  // 1. node ids unique + non-empty
+  const idSet = new Set<string>();
+  for (const n of g.nodes) {
+    if (!n || typeof n.id !== 'string' || n.id.length === 0) {
+      throw new Error('Every node must have a non-empty string id');
+    }
+    if (idSet.has(n.id)) {
+      throw new Error(`Duplicate node id: "${n.id}"`);
+    }
+    idSet.add(n.id);
+    if (typeof n.type !== 'string' || n.type.length === 0) {
+      throw new Error(`Node "${n.id}" must have a non-empty string type`);
+    }
+  }
+
+  // 2. at least one trigger node
+  const hasTrigger = g.nodes.some((n) => n.type!.endsWith('_trigger'));
+  if (!hasTrigger) {
+    throw new Error('DSL must contain at least one *_trigger node');
+  }
+
+  // 3. edges reference existing nodes; no self-loops
+  for (const e of g.edges) {
+    if (!e || typeof e.source !== 'string' || typeof e.target !== 'string') {
+      throw new Error('Every edge must have string source and target');
+    }
+    if (!idSet.has(e.source)) {
+      throw new Error(`Edge references unknown source node "${e.source}"`);
+    }
+    if (!idSet.has(e.target)) {
+      throw new Error(`Edge references unknown target node "${e.target}"`);
+    }
+    if (e.source === e.target) {
+      throw new Error(`Self-loop detected on node "${e.source}"`);
+    }
+  }
+
+  // 4. cycle detection — Kahn's algorithm.
+  // 注意：parallel/for_each 节点的"分支"在 worker 侧也是普通的 edge，因此用普通 DAG 校验即可。
+  const indegree = new Map<string, number>();
+  const adj = new Map<string, string[]>();
+  for (const id of idSet) {
+    indegree.set(id, 0);
+    adj.set(id, []);
+  }
+  for (const e of g.edges) {
+    indegree.set(e.target!, indegree.get(e.target!)! + 1);
+    adj.get(e.source!)!.push(e.target!);
+  }
+
+  const queue: string[] = [];
+  for (const [id, deg] of indegree) {
+    if (deg === 0) queue.push(id);
+  }
+
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift()!;
+    visited++;
+    for (const next of adj.get(id) || []) {
+      const d = indegree.get(next)! - 1;
+      indegree.set(next, d);
+      if (d === 0) queue.push(next);
+    }
+  }
+
+  if (visited !== idSet.size) {
+    const stuck = [...indegree.entries()]
+      .filter(([, d]) => d > 0)
+      .map(([id]) => id);
+    throw new Error(
+      `DSL contains a cycle. Nodes still in cycle or downstream of one: [${stuck.join(
+        ', ',
+      )}]`,
+    );
+  }
+}