[sync] T2445: support v2 table duplication (#1491) (#2811)

Synced from teableio/teable-ee@1c2e2c9

Co-authored-by: nichenqin <nichenqin@hotmail.com>

Author: tea-artist

apps/nestjs-backend/src/features/base-node/base-node.controller.ts

@@ -24,6 +24,7 @@ import {
   type IBaseNodeTreeVo,
   type IBaseNodeVo,
   type IDeleteBaseNodeVo,
+  type V2Feature,
 } from '@teable/openapi';
 import type { Response } from 'express';
 import { ClsService } from 'nestjs-cls';
@@ -35,6 +36,7 @@ import { AllowAnonymous, AllowAnonymousType } from '../auth/decorators/allow-ano
 import { BaseNodePermissions } from '../auth/decorators/base-node-permissions.decorator';
 import { Permissions } from '../auth/decorators/permissions.decorator';
 import { BaseNodePermissionGuard } from '../auth/guard/base-node-permission.guard';
+import type { IV2Decision } from '../canary/canary.service';
 import {
   X_TEABLE_V2_FEATURE_HEADER,
   X_TEABLE_V2_HEADER,
@@ -49,6 +51,7 @@ import { BaseNodeAction } from './types';
 @AllowAnonymous(AllowAnonymousType.RESOURCE)
 export class BaseNodeController {
   protected static readonly createTableV2Feature = 'createTable';
+  protected static readonly duplicateTableV2Feature = 'duplicateTable';
   protected static readonly deleteTableV2Feature = 'deleteTable';
 
   constructor(
@@ -160,8 +163,11 @@ export class BaseNodeController {
   async duplicate(
     @Param('baseId') baseId: string,
     @Param('nodeId') nodeId: string,
-    @Body(new ZodValidationPipe(duplicateBaseNodeRoSchema)) ro: IDuplicateBaseNodeRo
+    @Body(new ZodValidationPipe(duplicateBaseNodeRoSchema)) ro: IDuplicateBaseNodeRo,
+    @Headers('x-window-id') windowId: string | undefined,
+    @Res({ passthrough: true }) response: Response
   ): Promise<IBaseNodeVo> {
+    await this.prepareDuplicateTableCanary(baseId, nodeId, response, windowId);
     return this.baseNodeService.duplicate(baseId, nodeId, ro);
   }
 
@@ -221,55 +227,84 @@ export class BaseNodeController {
     nodeId: string,
     response: Response,
     windowId?: string
+  ): Promise<void> {
+    await this.prepareTableNodeCanary(
+      baseId,
+      nodeId,
+      response,
+      BaseNodeController.deleteTableV2Feature,
+      windowId
+    );
+  }
+
+  protected async prepareDuplicateTableCanary(
+    baseId: string,
+    nodeId: string,
+    response: Response,
+    windowId?: string
+  ): Promise<void> {
+    await this.prepareTableNodeCanary(
+      baseId,
+      nodeId,
+      response,
+      BaseNodeController.duplicateTableV2Feature,
+      windowId
+    );
+  }
+
+  protected async prepareCreateTableCanary(
+    baseId: string,
+    createRo: ICreateBaseNodeRo,
+    response: Response,
+    windowId?: string
   ): Promise<void> {
     if (windowId) {
       this.cls.set('windowId', windowId);
     }
 
-    const node = await this.baseNodeService.getNode(baseId, nodeId);
-    if (node.resourceType !== BaseNodeResourceType.Table) {
+    if (createRo.resourceType !== BaseNodeResourceType.Table) {
       return;
     }
 
-    const decision = await this.baseNodeService.getDeleteTableV2Decision(baseId, nodeId);
+    const decision = await this.baseNodeService.getCreateTableV2Decision(baseId);
     if (!decision) {
       return;
     }
 
-    this.cls.set('useV2', decision.useV2);
-    this.cls.set('v2Feature', BaseNodeController.deleteTableV2Feature);
-    this.cls.set('v2Reason', decision.reason);
-
-    response.setHeader(X_TEABLE_V2_HEADER, decision.useV2 ? 'true' : 'false');
-    response.setHeader(X_TEABLE_V2_FEATURE_HEADER, BaseNodeController.deleteTableV2Feature);
-    response.setHeader(X_TEABLE_V2_REASON_HEADER, decision.reason);
+    this.applyV2Decision(response, BaseNodeController.createTableV2Feature, decision);
   }
 
-  protected async prepareCreateTableCanary(
+  protected async prepareTableNodeCanary(
     baseId: string,
-    createRo: ICreateBaseNodeRo,
+    nodeId: string,
     response: Response,
+    feature: V2Feature,
     windowId?: string
   ): Promise<void> {
     if (windowId) {
       this.cls.set('windowId', windowId);
     }
 
-    if (createRo.resourceType !== BaseNodeResourceType.Table) {
+    const node = await this.baseNodeService.getNode(baseId, nodeId);
+    if (node.resourceType !== BaseNodeResourceType.Table) {
       return;
     }
 
-    const decision = await this.baseNodeService.getCreateTableV2Decision(baseId);
+    const decision = await this.baseNodeService.getTableV2Decision(baseId, nodeId, feature);
     if (!decision) {
       return;
     }
 
+    this.applyV2Decision(response, feature, decision);
+  }
+
+  protected applyV2Decision(response: Response, feature: V2Feature, decision: IV2Decision) {
     this.cls.set('useV2', decision.useV2);
-    this.cls.set('v2Feature', BaseNodeController.createTableV2Feature);
+    this.cls.set('v2Feature', feature);
     this.cls.set('v2Reason', decision.reason);
 
     response.setHeader(X_TEABLE_V2_HEADER, decision.useV2 ? 'true' : 'false');
-    response.setHeader(X_TEABLE_V2_FEATURE_HEADER, BaseNodeController.createTableV2Feature);
+    response.setHeader(X_TEABLE_V2_FEATURE_HEADER, feature);
     response.setHeader(X_TEABLE_V2_REASON_HEADER, decision.reason);
   }
 

apps/nestjs-backend/src/features/base-node/base-node.service.spec.ts

@@ -1,5 +1,6 @@
 import type { TestingModule } from '@nestjs/testing';
 import { Test } from '@nestjs/testing';
+import { BaseNodeResourceType } from '@teable/openapi';
 import type { Knex } from 'knex';
 import { GlobalModule } from '../../global/global.module';
 import { BaseNodeModule } from './base-node.module';
@@ -9,6 +10,24 @@ import { buildBatchUpdateSql } from './helper';
 describe('BaseNodeService', () => {
   let service: BaseNodeService;
   let knex: Knex;
+  const baseId = 'bse1';
+  const tableId = 'tbl1';
+  const tableName = 'Projects Copy';
+  const tableIcon = '📋';
+
+  type IDuplicateResourceInvoker = {
+    duplicateResource: (
+      baseId: string,
+      type: BaseNodeResourceType,
+      id: string,
+      duplicateRo: { name: string; includeRecords: boolean }
+    ) => Promise<{
+      id: string;
+      name: string;
+      icon?: string;
+      defaultViewId?: string;
+    }>;
+  };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -131,4 +150,94 @@ describe('BaseNodeService', () => {
       expect(result).toBe(expectedSql);
     });
   });
+
+  describe('duplicateResource', () => {
+    const createDuplicateRoutingService = (useV2: boolean) => {
+      const tableOpenApiV2Service = {
+        duplicateTable: vi.fn().mockResolvedValue({
+          id: 'tbl-v2-copy',
+          name: tableName,
+          icon: tableIcon,
+          defaultViewId: 'viwV2',
+        }),
+      };
+      const tableDuplicateService = {
+        duplicateTable: vi.fn().mockResolvedValue({
+          id: 'tbl-v1-copy',
+          name: tableName,
+          icon: tableIcon,
+          defaultViewId: 'viwLegacy',
+        }),
+      };
+      const routingService = new BaseNodeService(
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {
+          get: vi.fn((key: string) => (key === 'useV2' ? useV2 : undefined)),
+          set: vi.fn(),
+        } as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        tableOpenApiV2Service as never,
+        tableDuplicateService as never,
+        {} as never
+      );
+
+      return {
+        routingService,
+        tableOpenApiV2Service,
+        tableDuplicateService,
+      };
+    };
+
+    it('routes table duplication through v2 when useV2 is enabled', async () => {
+      const { routingService, tableOpenApiV2Service, tableDuplicateService } =
+        createDuplicateRoutingService(true);
+      const duplicateRo = { name: tableName, includeRecords: true };
+
+      const result = await (
+        routingService as unknown as IDuplicateResourceInvoker
+      ).duplicateResource(baseId, BaseNodeResourceType.Table, tableId, duplicateRo);
+
+      expect(tableOpenApiV2Service.duplicateTable).toHaveBeenCalledWith(
+        baseId,
+        tableId,
+        duplicateRo
+      );
+      expect(tableDuplicateService.duplicateTable).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        id: 'tbl-v2-copy',
+        name: tableName,
+        icon: tableIcon,
+        defaultViewId: 'viwV2',
+      });
+    });
+
+    it('keeps the legacy duplicate path when useV2 is disabled', async () => {
+      const { routingService, tableOpenApiV2Service, tableDuplicateService } =
+        createDuplicateRoutingService(false);
+      const duplicateRo = { name: tableName, includeRecords: false };
+
+      const result = await (
+        routingService as unknown as IDuplicateResourceInvoker
+      ).duplicateResource(baseId, BaseNodeResourceType.Table, tableId, duplicateRo);
+
+      expect(tableDuplicateService.duplicateTable).toHaveBeenCalledWith(
+        baseId,
+        tableId,
+        duplicateRo
+      );
+      expect(tableOpenApiV2Service.duplicateTable).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        id: 'tbl-v1-copy',
+        name: tableName,
+        icon: tableIcon,
+        defaultViewId: 'viwLegacy',
+      });
+    });
+  });
 });

apps/nestjs-backend/src/features/base-node/base-node.service.ts

@@ -20,6 +20,7 @@ import type {
   IBaseNodePresenceDeletePayload,
   IBaseNodePresenceUpdatePayload,
   IBaseNodeTableResourceMeta,
+  V2Feature,
 } from '@teable/openapi';
 import { BaseNodeResourceType } from '@teable/openapi';
 import { Knex } from 'knex';
@@ -124,7 +125,11 @@ export class BaseNodeService {
     };
   }
 
-  async getDeleteTableV2Decision(baseId: string, nodeId: string): Promise<IV2Decision | undefined> {
+  async getTableV2Decision(
+    baseId: string,
+    nodeId: string,
+    feature: V2Feature
+  ): Promise<IV2Decision | undefined> {
     const node = await this.prismaService.baseNode.findFirst({
       where: { baseId, id: nodeId },
       select: { resourceType: true },
@@ -143,7 +148,11 @@ export class BaseNodeService {
       return { useV2: false, reason: 'disabled' };
     }
 
-    return this.canaryService.shouldUseV2WithReason(base.spaceId, 'deleteTable');
+    return this.canaryService.shouldUseV2WithReason(base.spaceId, feature);
+  }
+
+  async getDeleteTableV2Decision(baseId: string, nodeId: string): Promise<IV2Decision | undefined> {
+    return this.getTableV2Decision(baseId, nodeId, 'deleteTable');
   }
 
   async getCreateTableV2Decision(baseId: string): Promise<IV2Decision | undefined> {
@@ -621,11 +630,17 @@ export class BaseNodeService {
   ): Promise<IBaseNodeResourceMetaWithId> {
     switch (type) {
       case BaseNodeResourceType.Table: {
-        const table = await this.tableDuplicateService.duplicateTable(
-          baseId,
-          id,
-          duplicateRo as IDuplicateTableRo
-        );
+        const table = this.cls.get('useV2')
+          ? await this.tableOpenApiV2Service.duplicateTable(
+              baseId,
+              id,
+              duplicateRo as IDuplicateTableRo
+            )
+          : await this.tableDuplicateService.duplicateTable(
+              baseId,
+              id,
+              duplicateRo as IDuplicateTableRo
+            );
 
         return {
           id: table.id,