fix: fix lookup filter by the projection

Author: nichenqin

apps/nestjs-backend/src/features/record/query-builder/field-cte-visitor.ts

@@ -1882,12 +1882,12 @@ export class FieldCteVisitor implements IFieldVisitor<ICteResult> {
     const { fkHostTableName, selfKeyName, foreignKeyName, relationship } = options;
 
     // Determine which lookup/rollup fields are actually needed from this link
-    let lookupFields = linkField.getLookupFields(this.table);
-    let rollupFields = linkField.getRollupFields(this.table);
-    if (this.filteredIdSet) {
-      lookupFields = lookupFields.filter((f) => this.filteredIdSet!.has(f.id));
-      rollupFields = rollupFields.filter((f) => this.filteredIdSet!.has(f.id));
-    }
+    // NOTE: We intentionally do not filter by the projection (filteredIdSet). A lookup that
+    // is not part of the direct projection can still be an intermediate dependency for
+    // another lookup/rollup selected via a different table. Filtering here can therefore
+    // omit required CTE columns, leading to generated SQL that references non-existent
+    const lookupFields = linkField.getLookupFields(this.table);
+    const rollupFields = linkField.getRollupFields(this.table);
 
     // Pre-generate nested CTEs limited to selected lookup/rollup dependencies
     this.generateNestedForeignCtesIfNeeded(

apps/nestjs-backend/test/lookup.e2e-spec.ts

@@ -675,6 +675,196 @@ describe('OpenAPI Lookup field (e2e)', () => {
     });
   });
 
+  describe('nested lookup dependencies', () => {
+    let usersTable: ITableFullVo;
+    let projectsTable: ITableFullVo;
+    let tasksTable: ITableFullVo;
+    let userNameField: IFieldVo;
+    let projectNameField: IFieldVo;
+    let taskNameField: IFieldVo;
+    let projectOwnerLookupField: IFieldVo;
+    let taskOwnerLookupField: IFieldVo;
+    let projectLinkFieldId: string;
+    let taskLinkFieldId: string;
+    let userRecordId: string;
+    let projectRecordId: string;
+    let taskRecordId: string;
+
+    const refreshFields = async (table: ITableFullVo) => {
+      table.fields = await getFields(table.id);
+    };
+
+    const getFieldByName = (fields: IFieldVo[], name: string) => {
+      const field = fields.find((f) => f.name === name);
+      if (!field) {
+        throw new Error(`Field ${name} not found`);
+      }
+      return field;
+    };
+
+    beforeAll(async () => {
+      usersTable = await createTable(baseId, {
+        name: 'lookup-nested-users',
+        fields: [
+          {
+            name: 'User Name',
+            type: FieldType.SingleLineText,
+            options: {},
+          },
+        ],
+      });
+
+      projectsTable = await createTable(baseId, {
+        name: 'lookup-nested-projects',
+        fields: [
+          {
+            name: 'Project Name',
+            type: FieldType.SingleLineText,
+            options: {},
+          },
+        ],
+      });
+
+      tasksTable = await createTable(baseId, {
+        name: 'lookup-nested-tasks',
+        fields: [
+          {
+            name: 'Task Name',
+            type: FieldType.SingleLineText,
+            options: {},
+          },
+        ],
+      });
+
+      await refreshFields(usersTable);
+      await refreshFields(projectsTable);
+      await refreshFields(tasksTable);
+
+      userNameField = getFieldByName(usersTable.fields, 'User Name');
+      projectNameField = getFieldByName(projectsTable.fields, 'Project Name');
+      taskNameField = getFieldByName(tasksTable.fields, 'Task Name');
+
+      const projectLinkField = await createField(projectsTable.id, {
+        name: 'Project -> User',
+        type: FieldType.Link,
+        options: {
+          relationship: Relationship.ManyOne,
+          foreignTableId: usersTable.id,
+        },
+      });
+      projectLinkFieldId = projectLinkField.id;
+
+      await refreshFields(projectsTable);
+      await refreshFields(usersTable);
+
+      projectOwnerLookupField = await createField(projectsTable.id, {
+        name: 'Project Owner (lookup)',
+        type: FieldType.SingleLineText,
+        isLookup: true,
+        lookupOptions: {
+          foreignTableId: usersTable.id,
+          linkFieldId: projectLinkFieldId,
+          lookupFieldId: userNameField.id,
+        } as ILookupOptionsRo,
+      });
+
+      await refreshFields(projectsTable);
+
+      const taskLinkField = await createField(tasksTable.id, {
+        name: 'Task -> Project',
+        type: FieldType.Link,
+        options: {
+          relationship: Relationship.ManyOne,
+          foreignTableId: projectsTable.id,
+        },
+      });
+      taskLinkFieldId = taskLinkField.id;
+
+      await refreshFields(tasksTable);
+      await refreshFields(projectsTable);
+
+      taskOwnerLookupField = await createField(tasksTable.id, {
+        name: 'Task Project Owner (lookup)',
+        type: FieldType.SingleLineText,
+        isLookup: true,
+        lookupOptions: {
+          foreignTableId: projectsTable.id,
+          linkFieldId: taskLinkFieldId,
+          lookupFieldId: projectOwnerLookupField.id,
+        } as ILookupOptionsRo,
+      });
+
+      await refreshFields(tasksTable);
+
+      const createdUsers = await createRecords(usersTable.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [
+          {
+            fields: {
+              [userNameField.id]: 'Alice',
+            },
+          },
+        ],
+      });
+      userRecordId = createdUsers.records[0].id;
+
+      const createdProjects = await createRecords(projectsTable.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [
+          {
+            fields: {
+              [projectNameField.id]: 'Project Alpha',
+            },
+          },
+        ],
+      });
+      projectRecordId = createdProjects.records[0].id;
+
+      await updateRecordByApi(projectsTable.id, projectRecordId, projectLinkFieldId, {
+        id: userRecordId,
+      });
+
+      const createdTasks = await createRecords(tasksTable.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [
+          {
+            fields: {
+              [taskNameField.id]: 'Task 1',
+            },
+          },
+        ],
+      });
+      taskRecordId = createdTasks.records[0].id;
+
+      await updateRecordByApi(tasksTable.id, taskRecordId, taskLinkFieldId, {
+        id: projectRecordId,
+      });
+    });
+
+    afterAll(async () => {
+      await permanentDeleteTable(baseId, tasksTable.id);
+      await permanentDeleteTable(baseId, projectsTable.id);
+      await permanentDeleteTable(baseId, usersTable.id);
+    });
+
+    it('should recompute nested lookup values after relinking', async () => {
+      let taskRecord = await getRecord(tasksTable.id, taskRecordId);
+      expect(taskRecord.fields[taskOwnerLookupField.id]).toEqual('Alice');
+
+      await updateRecordByApi(tasksTable.id, taskRecordId, taskLinkFieldId, null);
+
+      taskRecord = await getRecord(tasksTable.id, taskRecordId);
+      expect(taskRecord.fields[taskOwnerLookupField.id]).toBeUndefined();
+
+      await updateRecordByApi(tasksTable.id, taskRecordId, taskLinkFieldId, {
+        id: projectRecordId,
+      });
+
+      taskRecord = await getRecord(tasksTable.id, taskRecordId);
+      expect(taskRecord.fields[taskOwnerLookupField.id]).toEqual('Alice');
+    });
+  });
+
   describe('lookup filter', () => {
     let table1: ITableFullVo;
     let table2: ITableFullVo;