@gadmin2n/schematics 0.0.136 → 0.0.138

package/dist/lib/application/files/gadmin2-game-angle-demo/server/seed/workflow.seed.ts

@@ -60,12 +60,20 @@ export async function seedWorkflowModule(prisma: PrismaClient): Promise<void> {
     },
     {
       code: 'workflow_node_instance',
-      zhName: 'Node模版',
+      zhName: 'Node 实例',
       enName: 'Node Instance',
       sortOrder: 2,
       resourceCode: 'workflowNodeInstance',
       resourceDescription: 'Workflow node instance management',
     },
+    {
+      code: 'workflow_temporal_tenant',
+      zhName: '服务注册',
+      enName: 'Service Registration',
+      sortOrder: 3,
+      resourceCode: 'temporalTenantConfig',
+      resourceDescription: 'Temporal tenant config management',
+    },
   ];
 
   const allPages = [{ id: workflowPage.id, code: workflowPage.code }];

package/dist/lib/application/files/gadmin2-game-angle-demo/server/seed/workflows.ts

@@ -24,24 +24,28 @@ const WORKFLOWS = [
           type: 'http_request',
           label: '拉取外部数据',
           position: { x: 350, y: 200 },
+          config: {},
         },
         {
           id: 'action_2',
           type: 'code',
           label: '数据转换',
           position: { x: 600, y: 200 },
+          config: {},
         },
         {
           id: 'action_3',
           type: 'db_execute',
           label: '写入数据库',
           position: { x: 850, y: 200 },
+          config: {},
         },
         {
           id: 'action_4',
           type: 'send_notification',
           label: '发送通知',
           position: { x: 1100, y: 200 },
+          config: {},
         },
       ],
       edges: [
@@ -72,36 +76,42 @@ const WORKFLOWS = [
           type: 'set_variable',
           label: '提取用户信息',
           position: { x: 350, y: 200 },
+          config: {},
         },
         {
           id: 'approval_1',
           type: 'approval',
           label: '管理员审批',
           position: { x: 600, y: 200 },
+          config: {},
         },
         {
           id: 'condition_1',
           type: 'if_else',
           label: '审批结果判断',
           position: { x: 850, y: 200 },
+          config: {},
         },
         {
           id: 'action_2',
           type: 'db_execute',
           label: '激活用户',
           position: { x: 1100, y: 100 },
+          config: {},
         },
         {
           id: 'action_3',
           type: 'send_notification',
           label: '发送欢迎邮件',
           position: { x: 1350, y: 100 },
+          config: {},
         },
         {
           id: 'action_4',
           type: 'send_notification',
           label: '发送拒绝通知',
           position: { x: 1100, y: 300 },
+          config: {},
         },
       ],
       edges: [
@@ -146,30 +156,35 @@ const WORKFLOWS = [
           type: 'event_trigger',
           label: '监听错误事件',
           position: { x: 100, y: 200 },
+          config: {},
         },
         {
           id: 'action_1',
           type: 'db_query',
           label: '查询近5分钟错误数',
           position: { x: 350, y: 200 },
+          config: {},
         },
         {
           id: 'condition_1',
           type: 'if_else',
           label: '错误率 > 5%?',
           position: { x: 600, y: 200 },
+          config: {},
         },
         {
           id: 'action_2',
           type: 'send_notification',
           label: '发送告警',
           position: { x: 850, y: 100 },
+          config: {},
         },
         {
           id: 'action_3',
           type: 'code',
           label: '记录日志',
           position: { x: 850, y: 300 },
+          config: {},
         },
       ],
       edges: [
@@ -214,24 +229,28 @@ const WORKFLOWS = [
           type: 'db_query',
           label: '查询数据',
           position: { x: 350, y: 200 },
+          config: {},
         },
         {
           id: 'loop_1',
           type: 'for_each',
           label: '遍历分页',
           position: { x: 600, y: 200 },
+          config: {},
         },
         {
           id: 'action_2',
           type: 'code',
           label: '转换为CSV',
           position: { x: 850, y: 200 },
+          config: {},
         },
         {
           id: 'action_3',
           type: 'send_notification',
           label: '发送邮件',
           position: { x: 1100, y: 200 },
+          config: {},
         },
       ],
       edges: [
@@ -262,30 +281,35 @@ const WORKFLOWS = [
           type: 'parallel',
           label: '并行部署',
           position: { x: 350, y: 200 },
+          config: {},
         },
         {
           id: 'action_1',
           type: 'http_request',
           label: '部署 Staging',
           position: { x: 600, y: 100 },
+          config: {},
         },
         {
           id: 'approval_1',
           type: 'approval',
           label: 'Production 审批',
           position: { x: 600, y: 300 },
+          config: {},
         },
         {
           id: 'action_2',
           type: 'http_request',
           label: '部署 Production',
           position: { x: 850, y: 300 },
+          config: {},
         },
         {
           id: 'action_3',
           type: 'send_notification',
           label: '部署完成通知',
           position: { x: 1100, y: 200 },
+          config: {},
         },
       ],
       edges: [

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/canvas/canvas-export.dto.ts

@@ -0,0 +1,27 @@
+import { IsObject } from 'class-validator';
+
+export class ImportPayloadDto {
+  @IsObject()
+  payload: ExportPayload;
+}
+
+export interface ExportPayload {
+  version: number;
+  exportedAt: string;
+  canvas: {
+    code: string;
+    name: string;
+    items: any[];
+    layout: any[];
+  };
+  savedQueries: Array<{
+    sourceId: string;
+    sql: string;
+    description: string;
+  }>;
+}
+
+export interface ImportPreviewResponse {
+  current: Partial<ExportPayload> | null;
+  incoming: ExportPayload;
+}

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

@@ -0,0 +1,430 @@
+import { NotFoundException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { PrismaService } from 'nestjs-prisma';
+import { CanvasExportService } from './canvas-export.service';
+
+describe('CanvasExportService', () => {
+  let service: CanvasExportService;
+  let prisma: any;
+
+  beforeEach(async () => {
+    prisma = {
+      canvas: {
+        findUnique: jest.fn(),
+        findFirst: jest.fn(),
+        upsert: jest.fn(),
+      },
+      savedQuery: {
+        findMany: jest.fn(),
+        findFirst: jest.fn(),
+        create: jest.fn(),
+      },
+      page: {
+        findFirst: jest.fn(),
+        delete: jest.fn(),
+      },
+      rolePages: {
+        deleteMany: jest.fn(),
+      },
+      $transaction: jest.fn(async (cb: any) =>
+        cb({
+          canvas: prisma.canvas,
+          savedQuery: prisma.savedQuery,
+          page: prisma.page,
+          rolePages: prisma.rolePages,
+        }),
+      ),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CanvasExportService,
+        { provide: PrismaService, useValue: prisma },
+      ],
+    }).compile();
+
+    service = module.get<CanvasExportService>(CanvasExportService);
+  });
+
+  describe('generateExportToken', () => {
+    it('throws NotFoundException when canvas does not exist', async () => {
+      prisma.canvas.findUnique.mockResolvedValueOnce(null);
+
+      await expect(
+        service.generateExportToken('nonexistent-id', 'https://example.com'),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('returns a URL containing the canvas code and a token', async () => {
+      prisma.canvas.findUnique.mockResolvedValueOnce({ code: 'cv_abc123' });
+
+      const result = await service.generateExportToken(
+        'canvas-id-1',
+        'https://example.com/api',
+      );
+
+      expect(result.url).toContain(
+        'https://example.com/api/canvas/export/cv_abc123?token=',
+      );
+      expect(prisma.canvas.findUnique).toHaveBeenCalledWith({
+        where: { id: 'canvas-id-1' },
+        select: { code: true },
+      });
+    });
+  });
+
+  describe('getExportPayload', () => {
+    const CODE = 'cv_abc123';
+    let validToken: string;
+
+    beforeEach(() => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const jwt = require('jsonwebtoken');
+      validToken = jwt.sign(
+        { canvasCode: CODE },
+        process.env.TAIHU_ODC_APP_TOKEN || 'gadmin-default-secret',
+        { expiresIn: 1800 },
+      );
+    });
+
+    it('throws UnauthorizedException for invalid token', async () => {
+      await expect(
+        service.getExportPayload(CODE, 'garbage-token'),
+      ).rejects.toThrow('Export token is invalid or expired');
+    });
+
+    it('throws UnauthorizedException when token code mismatches', async () => {
+      await expect(
+        service.getExportPayload('different-code', validToken),
+      ).rejects.toThrow('Token does not match this canvas');
+    });
+
+    it('throws NotFoundException when canvas does not exist', async () => {
+      prisma.canvas.findUnique.mockResolvedValueOnce(null);
+
+      await expect(service.getExportPayload(CODE, validToken)).rejects.toThrow(
+        'Canvas not found',
+      );
+    });
+
+    it('extracts referenced SavedQuery ids from item code and includes them in payload', async () => {
+      prisma.canvas.findUnique.mockResolvedValueOnce({
+        code: CODE,
+        name: 'My Dashboard',
+        items: [
+          {
+            id: 'item1',
+            componentType: 'Table',
+            code: "fetch('/api/canvas/saved-query/42/run')",
+          },
+          {
+            id: 'item2',
+            componentType: 'BarChart',
+            code: "fetch('/api/canvas/saved-query/7/run')",
+          },
+        ],
+        layout: [{ i: 'item1', x: 0, y: 0, w: 4, h: 4 }],
+      });
+      prisma.savedQuery.findMany.mockResolvedValueOnce([
+        { id: 42, sql: 'SELECT * FROM t_a', description: 'desc a' },
+        { id: 7, sql: 'SELECT * FROM t_b', description: 'desc b' },
+      ]);
+
+      const result = await service.getExportPayload(CODE, validToken);
+
+      expect(prisma.savedQuery.findMany).toHaveBeenCalledWith({
+        where: { id: { in: [42, 7] } },
+      });
+      expect(result.canvas.code).toBe(CODE);
+      expect(result.canvas.name).toBe('My Dashboard');
+      expect(result.savedQueries).toEqual([
+        { sourceId: '42', sql: 'SELECT * FROM t_a', description: 'desc a' },
+        { sourceId: '7', sql: 'SELECT * FROM t_b', description: 'desc b' },
+      ]);
+    });
+
+    it('returns empty savedQueries when no items reference saved-query', async () => {
+      prisma.canvas.findUnique.mockResolvedValueOnce({
+        code: CODE,
+        name: 'Empty Dashboard',
+        items: [
+          { id: 'item1', componentType: 'NumCard', code: '<div>static</div>' },
+        ],
+        layout: [],
+      });
+
+      const result = await service.getExportPayload(CODE, validToken);
+
+      expect(prisma.savedQuery.findMany).not.toHaveBeenCalled();
+      expect(result.savedQueries).toEqual([]);
+    });
+  });
+
+  describe('importPreview', () => {
+    it('throws BadRequestException when payload has no canvas code', async () => {
+      await expect(
+        service.importPreview({
+          version: 1,
+          exportedAt: '',
+          canvas: {} as any,
+          savedQueries: [],
+        }),
+      ).rejects.toThrow('Invalid payload: missing canvas code');
+    });
+
+    it('returns current=null when no existing canvas matches the code', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce(null);
+
+      const payload = {
+        version: 1,
+        exportedAt: '2026-01-01T00:00:00.000Z',
+        canvas: { code: 'cv_new', name: 'New', items: [], layout: [] },
+        savedQueries: [],
+      };
+
+      const result = await service.importPreview(payload);
+
+      expect(result.current).toBeNull();
+      expect(result.incoming).toEqual(payload);
+    });
+
+    it('returns current with existing canvas data when code matches', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce({
+        code: 'cv_existing',
+        name: 'Old Name',
+        items: [{ id: 'x', componentType: 'Table', code: 'old' }],
+        layout: [{ i: 'x', x: 0, y: 0, w: 1, h: 1 }],
+      });
+
+      const payload = {
+        version: 1,
+        exportedAt: '2026-01-01T00:00:00.000Z',
+        canvas: {
+          code: 'cv_existing',
+          name: 'New Name',
+          items: [],
+          layout: [],
+        },
+        savedQueries: [],
+      };
+
+      const result = await service.importPreview(payload);
+
+      expect(result.current).toEqual({
+        canvas: {
+          code: 'cv_existing',
+          name: 'Old Name',
+          items: [{ id: 'x', componentType: 'Table', code: 'old' }],
+          layout: [{ i: 'x', x: 0, y: 0, w: 1, h: 1 }],
+        },
+      });
+      expect(result.incoming).toEqual(payload);
+    });
+  });
+
+  describe('importConfirm', () => {
+    it('throws BadRequestException when payload has no canvas code', async () => {
+      await expect(
+        service.importConfirm(
+          { version: 1, exportedAt: '', canvas: {} as any, savedQueries: [] },
+          'user-1',
+        ),
+      ).rejects.toThrow('Invalid payload: missing canvas code');
+    });
+
+    it('creates a new canvas owned by the importing user when code does not exist', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce(null); // 检查是否已存在（发布清理判断）
+      prisma.canvas.upsert.mockResolvedValueOnce({
+        id: 'new-canvas-id',
+        name: 'Imported Dashboard',
+      });
+
+      const payload = {
+        version: 1,
+        exportedAt: '2026-01-01T00:00:00.000Z',
+        canvas: {
+          code: 'cv_new',
+          name: 'Imported Dashboard',
+          items: [
+            { id: 'x', componentType: 'NumCard', code: '<div>static</div>' },
+          ],
+          layout: [],
+        },
+        savedQueries: [],
+      };
+
+      const result = await service.importConfirm(payload, 'user-1');
+
+      expect(prisma.canvas.upsert).toHaveBeenCalledWith({
+        where: { code: 'cv_new' },
+        create: {
+          code: 'cv_new',
+          name: 'Imported Dashboard',
+          userId: 'user-1',
+          items: payload.canvas.items,
+          layout: [],
+        },
+        update: {
+          name: 'Imported Dashboard',
+          items: payload.canvas.items,
+          layout: [],
+        },
+      });
+      expect(result).toEqual({
+        success: true,
+        canvasId: 'new-canvas-id',
+        canvasName: 'Imported Dashboard',
+      });
+    });
+
+    it('reuses existing SavedQuery id when sql text matches, and rewrites item code', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce(null);
+      prisma.savedQuery.findFirst.mockResolvedValueOnce({
+        id: 99,
+        sql: 'SELECT 1',
+        description: 'd',
+      });
+      prisma.canvas.upsert.mockResolvedValueOnce({ id: 'cid', name: 'N' });
+
+      const payload = {
+        version: 1,
+        exportedAt: '',
+        canvas: {
+          code: 'cv_x',
+          name: 'N',
+          items: [
+            {
+              id: 'i1',
+              componentType: 'Table',
+              code: "fetch('/api/canvas/saved-query/42/run')",
+            },
+          ],
+          layout: [],
+        },
+        savedQueries: [{ sourceId: '42', sql: 'SELECT 1', description: 'd' }],
+      };
+
+      await service.importConfirm(payload, 'user-1');
+
+      expect(prisma.savedQuery.findFirst).toHaveBeenCalledWith({
+        where: { sql: 'SELECT 1' },
+      });
+      expect(prisma.savedQuery.create).not.toHaveBeenCalled();
+      expect(prisma.canvas.upsert).toHaveBeenCalledWith(
+        expect.objectContaining({
+          create: expect.objectContaining({
+            items: [
+              {
+                id: 'i1',
+                componentType: 'Table',
+                code: "fetch('/api/canvas/saved-query/99/run')",
+              },
+            ],
+          }),
+        }),
+      );
+    });
+
+    it('creates a new SavedQuery when no matching sql exists in target env', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce(null);
+      prisma.savedQuery.findFirst.mockResolvedValueOnce(null);
+      prisma.savedQuery.create.mockResolvedValueOnce({
+        id: 100,
+        sql: 'SELECT 2',
+        description: 'd2',
+      });
+      prisma.canvas.upsert.mockResolvedValueOnce({ id: 'cid', name: 'N' });
+
+      const payload = {
+        version: 1,
+        exportedAt: '',
+        canvas: {
+          code: 'cv_y',
+          name: 'N',
+          items: [
+            {
+              id: 'i1',
+              componentType: 'Table',
+              code: "fetch('/api/canvas/saved-query/7/run')",
+            },
+          ],
+          layout: [],
+        },
+        savedQueries: [{ sourceId: '7', sql: 'SELECT 2', description: 'd2' }],
+      };
+
+      await service.importConfirm(payload, 'user-1');
+
+      expect(prisma.savedQuery.create).toHaveBeenCalledWith({
+        data: { sql: 'SELECT 2', description: 'd2' },
+      });
+      expect(prisma.canvas.upsert).toHaveBeenCalledWith(
+        expect.objectContaining({
+          create: expect.objectContaining({
+            items: [
+              {
+                id: 'i1',
+                componentType: 'Table',
+                code: "fetch('/api/canvas/saved-query/100/run')",
+              },
+            ],
+          }),
+        }),
+      );
+    });
+
+    it('cleans up Page and RolePages when overwriting an already-published canvas', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce({
+        id: 'existing-id',
+        code: 'cv_pub',
+        publishedPageCode: 'my-page-slug',
+      });
+      prisma.page.findFirst.mockResolvedValueOnce({ id: 5 });
+      prisma.canvas.upsert.mockResolvedValueOnce({
+        id: 'existing-id',
+        name: 'N',
+      });
+
+      const payload = {
+        version: 1,
+        exportedAt: '',
+        canvas: { code: 'cv_pub', name: 'N', items: [], layout: [] },
+        savedQueries: [],
+      };
+
+      await service.importConfirm(payload, 'user-1');
+
+      expect(prisma.page.findFirst).toHaveBeenCalledWith({
+        where: { code: 'my-page-slug' },
+      });
+      expect(prisma.rolePages.deleteMany).toHaveBeenCalledWith({
+        where: { pageId: 5 },
+      });
+      expect(prisma.page.delete).toHaveBeenCalledWith({ where: { id: 5 } });
+    });
+
+    it('does not touch Page/RolePages when overwriting a canvas that is not published', async () => {
+      prisma.canvas.findFirst.mockResolvedValueOnce({
+        id: 'existing-id',
+        code: 'cv_unpub',
+        publishedPageCode: null,
+      });
+      prisma.canvas.upsert.mockResolvedValueOnce({
+        id: 'existing-id',
+        name: 'N',
+      });
+
+      const payload = {
+        version: 1,
+        exportedAt: '',
+        canvas: { code: 'cv_unpub', name: 'N', items: [], layout: [] },
+        savedQueries: [],
+      };
+
+      await service.importConfirm(payload, 'user-1');
+
+      expect(prisma.page.findFirst).not.toHaveBeenCalled();
+      expect(prisma.rolePages.deleteMany).not.toHaveBeenCalled();
+    });
+  });
+});