[sync] fix(backend): bootstrap ai primary fields before duplicate links (#1511) (#2820)

Synced from teableio/teable-ee@8b62fee

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

Author: tea-artist

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

@@ -493,6 +493,10 @@ export class BaseImportService {
           .includes(id)
     );
 
+    const primaryDependencyFields = dependencyFields.filter(({ isPrimary, aiConfig, isLookup }) =>
+      Boolean(isPrimary && aiConfig && !isLookup)
+    );
+
     // helper: emit per-table progress with field names
     const emitFieldProgress = (
       phase: string,
@@ -522,6 +526,15 @@ export class BaseImportService {
     // main fix formula dbField type
     await this.fieldDuplicateService.repairPrimaryFormulaFields(primaryFormulaFields, fieldMap);
 
+    // Some valid primary fields are deferred to dependency creation, for example
+    // AI-config primaries. Bootstrap them before two-way link creation so
+    // generateSymmetricField can always resolve the current table primary.
+    emitFieldProgress('creating_primary_dependency_fields', primaryDependencyFields);
+    await this.fieldDuplicateService.bootstrapPrimaryDependencyFields(
+      primaryDependencyFields,
+      fieldMap
+    );
+
     emitFieldProgress('creating_link_fields', linkFields);
     await this.fieldDuplicateService.createLinkFields(linkFields, tableIdMap, fieldMap, fkMap);
 

apps/nestjs-backend/src/features/field/field-duplicate/field-duplicate.service.ts

@@ -886,6 +886,45 @@ export class FieldDuplicateService {
     }
   }
 
+  async bootstrapPrimaryDependencyFields(
+    fields: IFieldWithTableIdJson[],
+    sourceToTargetFieldMap: Record<string, string>
+  ) {
+    for (const field of fields) {
+      if (!field.isPrimary || !field.aiConfig || field.isLookup) continue;
+
+      const {
+        targetTableId,
+        type,
+        dbFieldName,
+        name,
+        options,
+        id,
+        notNull,
+        unique,
+        description,
+        order,
+      } = field;
+
+      const newField = await this.fieldOpenApiService.createField(targetTableId, {
+        type,
+        dbFieldName,
+        description,
+        options,
+        name,
+      });
+
+      await this.replenishmentConstraint(newField.id, targetTableId, order, {
+        notNull,
+        unique,
+        dbFieldName: newField.dbFieldName,
+        isPrimary: true,
+      });
+
+      sourceToTargetFieldMap[id] = newField.id;
+    }
+  }
+
   async duplicateSingleDependField(
     sourceTableId: string,
     targetTableId: string,
@@ -910,6 +949,15 @@ export class FieldDuplicateService {
       return;
     }
 
+    if (isAiConfig && sourceToTargetFieldMap[field.id]) {
+      await this.repairFieldAiConfig(
+        sourceToTargetFieldMap[field.id],
+        field as unknown as IFieldInstance,
+        sourceToTargetFieldMap
+      );
+      return;
+    }
+
     switch (true) {
       case isLookup:
         await this.duplicateLookupField(
@@ -1391,6 +1439,25 @@ export class FieldDuplicateService {
     }
   }
 
+  private mapAiConfigForDuplicate(
+    aiConfig: NonNullable<IFieldVo['aiConfig']>,
+    sourceToTargetFieldMap: Record<string, string>
+  ) {
+    const mappedAiConfig: IFieldVo['aiConfig'] = { ...aiConfig };
+
+    if ('sourceFieldId' in mappedAiConfig) {
+      mappedAiConfig.sourceFieldId = sourceToTargetFieldMap[mappedAiConfig.sourceFieldId as string];
+    }
+
+    if ('prompt' in mappedAiConfig) {
+      Object.entries(sourceToTargetFieldMap).forEach(([key, value]) => {
+        mappedAiConfig.prompt = mappedAiConfig.prompt.replaceAll(key, value);
+      });
+    }
+
+    return mappedAiConfig;
+  }
+
   private async duplicateFieldAiConfig(
     targetTableId: string,
     fieldInstance: IFieldInstance,
@@ -1400,18 +1467,7 @@ export class FieldDuplicateService {
 
     const { type, dbFieldName, name, options, id, notNull, unique, description, isPrimary } =
       fieldInstance;
-
-    const aiConfig: IFieldVo['aiConfig'] = { ...fieldInstance.aiConfig };
-
-    if ('sourceFieldId' in aiConfig) {
-      aiConfig.sourceFieldId = sourceToTargetFieldMap[aiConfig.sourceFieldId as string];
-    }
-
-    if ('prompt' in aiConfig) {
-      Object.entries(sourceToTargetFieldMap).forEach(([key, value]) => {
-        aiConfig.prompt = aiConfig.prompt.replaceAll(key, value);
-      });
-    }
+    const aiConfig = this.mapAiConfigForDuplicate(fieldInstance.aiConfig, sourceToTargetFieldMap);
 
     const newField = await this.fieldOpenApiService.createField(targetTableId, {
       type,
@@ -1431,6 +1487,25 @@ export class FieldDuplicateService {
     sourceToTargetFieldMap[id] = newField.id;
   }
 
+  private async repairFieldAiConfig(
+    targetFieldId: string,
+    fieldInstance: IFieldInstance,
+    sourceToTargetFieldMap: Record<string, string>
+  ) {
+    if (!fieldInstance.aiConfig) return;
+
+    const aiConfig = this.mapAiConfigForDuplicate(fieldInstance.aiConfig, sourceToTargetFieldMap);
+
+    await this.prismaService.txClient().field.update({
+      where: {
+        id: targetFieldId,
+      },
+      data: {
+        aiConfig: JSON.stringify(aiConfig),
+      },
+    });
+  }
+
   // field could not set constraint when create
   async replenishmentConstraint(
     fId: string,