@gadmin2n/schematics 0.0.135 → 0.0.137

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

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

@@ -0,0 +1,203 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { PrismaService } from 'nestjs-prisma';
+import { ExportPayload, ImportPreviewResponse } from './canvas-export.dto';
+
+const EXPORT_TOKEN_SECRET =
+  process.env.TAIHU_ODC_APP_TOKEN || 'gadmin-default-secret';
+const EXPORT_TOKEN_EXPIRY = 30 * 60; // 30 minutes in seconds
+
+// 匹配 Canvas Item 代码里硬编码的 saved-query 调用，如 fetch('/api/canvas/saved-query/42/run')
+const SAVED_QUERY_ID_PATTERN = /\/canvas\/saved-query\/(\d+)\/run/g;
+
+interface ExportTokenPayload {
+  canvasCode: string;
+}
+
+@Injectable()
+export class CanvasExportService {
+  constructor(private prisma: PrismaService) {}
+
+  /** Generate a JWT export token for a canvas */
+  async generateExportToken(
+    canvasId: string,
+    baseUrl: string,
+  ): Promise<{ url: string }> {
+    const canvas = await this.prisma.canvas.findUnique({
+      where: { id: canvasId },
+      select: { code: true },
+    });
+    if (!canvas) throw new NotFoundException('Canvas not found');
+
+    const token = jwt.sign(
+      { canvasCode: canvas.code } as ExportTokenPayload,
+      EXPORT_TOKEN_SECRET,
+      { expiresIn: EXPORT_TOKEN_EXPIRY },
+    );
+
+    const url = `${baseUrl}/canvas/export/${canvas.code}?token=${token}`;
+    return { url };
+  }
+
+  /** 从 canvas items 的 code 字符串里提取所有引用到的 SavedQuery id */
+  private extractSavedQueryIds(items: any[]): number[] {
+    const ids = new Set<number>();
+    for (const item of items ?? []) {
+      const code = item?.code ?? '';
+      let match: RegExpExecArray | null;
+      const pattern = new RegExp(SAVED_QUERY_ID_PATTERN);
+      while ((match = pattern.exec(code)) !== null) {
+        ids.add(Number(match[1]));
+      }
+    }
+    return Array.from(ids);
+  }
+
+  /** Verify export token and return the full export payload */
+  async getExportPayload(code: string, token: string): Promise<ExportPayload> {
+    let decoded: ExportTokenPayload;
+    try {
+      decoded = jwt.verify(token, EXPORT_TOKEN_SECRET) as ExportTokenPayload;
+    } catch {
+      throw new UnauthorizedException('Export token is invalid or expired');
+    }
+
+    if (decoded.canvasCode !== code) {
+      throw new UnauthorizedException('Token does not match this canvas');
+    }
+
+    const canvas = await this.prisma.canvas.findUnique({
+      where: { code },
+    });
+    if (!canvas) throw new NotFoundException('Canvas not found');
+
+    const items = (canvas.items as any[]) ?? [];
+    const savedQueryIds = this.extractSavedQueryIds(items);
+
+    const savedQueries =
+      savedQueryIds.length > 0
+        ? await this.prisma.savedQuery.findMany({
+            where: { id: { in: savedQueryIds } },
+          })
+        : [];
+
+    return {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      canvas: {
+        code: canvas.code,
+        name: canvas.name,
+        items,
+        layout: (canvas.layout as any[]) ?? [],
+      },
+      savedQueries: savedQueries.map((sq) => ({
+        sourceId: String(sq.id),
+        sql: sq.sql,
+        description: sq.description,
+      })),
+    };
+  }
+
+  /** Preview import — return current state vs incoming for diff */
+  async importPreview(payload: ExportPayload): Promise<ImportPreviewResponse> {
+    if (!payload?.canvas?.code) {
+      throw new BadRequestException('Invalid payload: missing canvas code');
+    }
+
+    const existing = await this.prisma.canvas.findFirst({
+      where: { code: payload.canvas.code },
+    });
+
+    const current: Partial<ExportPayload> | null = existing
+      ? {
+          canvas: {
+            code: existing.code,
+            name: existing.name,
+            items: (existing.items as any[]) ?? [],
+            layout: (existing.layout as any[]) ?? [],
+          },
+        }
+      : null;
+
+    return { current, incoming: payload };
+  }
+
+  /** Confirm import — execute upsert with SavedQuery id remapping in a transaction */
+  async importConfirm(
+    payload: ExportPayload,
+    userId: string,
+  ): Promise<{ success: boolean; canvasId: string; canvasName: string }> {
+    if (!payload?.canvas?.code) {
+      throw new BadRequestException('Invalid payload: missing canvas code');
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      // 1. 若目标环境已存在同 code 的已发布 Canvas，先清理旧的 Page/RolePages
+      const existing = await tx.canvas.findFirst({
+        where: { code: payload.canvas.code },
+      });
+      if (existing?.publishedPageCode) {
+        const page = await tx.page.findFirst({
+          where: { code: existing.publishedPageCode },
+        });
+        if (page) {
+          await tx.rolePages.deleteMany({ where: { pageId: page.id } });
+          await tx.page.delete({ where: { id: page.id } });
+        }
+      }
+
+      // 2. 按 sql 文本 upsert SavedQuery，建立 sourceId → newId 映射
+      const idMap = new Map<string, string>();
+      for (const sq of payload.savedQueries) {
+        let record = await tx.savedQuery.findFirst({ where: { sql: sq.sql } });
+        if (!record) {
+          record = await tx.savedQuery.create({
+            data: { sql: sq.sql, description: sq.description },
+          });
+        }
+        idMap.set(sq.sourceId, String(record.id));
+      }
+
+      // 3. 深拷贝 items，重写引用到的 saved-query id
+      const items = JSON.parse(JSON.stringify(payload.canvas.items ?? []));
+      for (const item of items) {
+        if (typeof item.code !== 'string') continue;
+        item.code = item.code.replace(
+          /\/canvas\/saved-query\/(\d+)\/run/g,
+          (match: string, oldId: string) => {
+            const newId = idMap.get(oldId);
+            return newId ? `/canvas/saved-query/${newId}/run` : match;
+          },
+        );
+      }
+
+      // 4. 按 code upsert Canvas（发布状态不参与导入，始终不带 publishedPageCode/publishedAt）
+      const canvas = await tx.canvas.upsert({
+        where: { code: payload.canvas.code },
+        create: {
+          code: payload.canvas.code,
+          name: payload.canvas.name,
+          userId,
+          items,
+          layout: payload.canvas.layout ?? [],
+        },
+        update: {
+          name: payload.canvas.name,
+          items,
+          layout: payload.canvas.layout ?? [],
+        },
+      });
+
+      return {
+        success: true,
+        canvasId: canvas.id,
+        canvasName: canvas.name,
+      };
+    });
+  }
+}

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

@@ -8,12 +8,15 @@ import {
   ParseIntPipe,
   Post,
   Put,
+  Query,
   Req,
-  UseGuards,
+  UnauthorizedException,
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { PrismaService } from 'nestjs-prisma';
-import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { ImportPayloadDto } from './canvas-export.dto';
+import { CanvasExportService } from './canvas-export.service';
 import {
   CreateCanvasDto,
   CreateSavedQueryDto,
@@ -23,12 +26,12 @@ import {
 import { CanvasService } from './canvas.service';
 
 @ApiTags('canvas')
-@UseGuards(AuthGuard)
 @Controller('canvas')
 export class CanvasController {
   constructor(
     private readonly canvasService: CanvasService,
     private readonly prisma: PrismaService,
+    private readonly canvasExportService: CanvasExportService,
   ) {}
 
   @Get()
@@ -98,6 +101,36 @@ export class CanvasController {
     return this.canvasService.remove(id, req.user.userid);
   }
 
+  // ─── Export/Import Endpoints ──────────────────────────────────────────────────
+
+  @Post(':id/export-token')
+  async generateExportToken(@Param('id') id: string, @Req() req) {
+    const baseUrl = `${req.protocol}://${req.get('host')}/api`;
+    return this.canvasExportService.generateExportToken(id, baseUrl);
+  }
+
+  @Get('export/:code')
+  @AllowUnauthorizedRequest()
+  async getExportPayload(
+    @Param('code') code: string,
+    @Query('token') token: string,
+  ) {
+    if (!token) {
+      throw new UnauthorizedException('Export token is required');
+    }
+    return this.canvasExportService.getExportPayload(code, token);
+  }
+
+  @Post('import-preview')
+  async importPreview(@Body() dto: ImportPayloadDto) {
+    return this.canvasExportService.importPreview(dto.payload);
+  }
+
+  @Post('import-confirm')
+  async importConfirm(@Body() dto: ImportPayloadDto, @Req() req) {
+    return this.canvasExportService.importConfirm(dto.payload, req.user.userid);
+  }
+
   @Post(':id/publish')
   publish(@Req() req, @Param('id') id: string, @Body() dto: PublishCanvasDto) {
     return this.canvasService.publish(id, req.user.userid, dto);