From f02da78c379e2d258fd760894699e67a360b3977 Mon Sep 17 00:00:00 2001
From: Artem Niehrieiev <r.tem@tuta.io>
Date: Wed, 12 Feb 2025 16:13:31 +0000
Subject: [PATCH 1/2] enhance GetTableRows use case by refining foreign key
 handling and improving row identity mapping logic for better data integrity

---
 .../use-cases/get-table-rows.use.case.ts      | 30 ++++++++++++-------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/backend/src/entities/table/use-cases/get-table-rows.use.case.ts b/backend/src/entities/table/use-cases/get-table-rows.use.case.ts
index 56a524fb..df72f079 100644
--- a/backend/src/entities/table/use-cases/get-table-rows.use.case.ts
+++ b/backend/src/entities/table/use-cases/get-table-rows.use.case.ts
@@ -68,6 +68,7 @@ export class GetTableRowsUseCase extends AbstractUseCase<GetTableRowsDs, FoundTa
       const dao = getDataAccessObject(connection);
       const tablesInConnection = await dao.getTablesFromDB();
       const tableNames = tablesInConnection.map((table) => table.tableName);
+
       if (!tableNames.includes(tableName)) {
         throw new BadRequestException(Messages.TABLE_NOT_FOUND);
       }
@@ -265,21 +266,28 @@ export class GetTableRowsUseCase extends AbstractUseCase<GetTableRowsDs, FoundTa
       const foreignKeysConformity = tableForeignKeys.map((key) => ({
         currentFKeyName: key.column_name,
         realFKeyName: key.referenced_column_name,
-        referenced_table_name: key.referenced_table_name,
+        referencedTableName: key.referenced_table_name,
       }));
 
-      foreignKeysConformity.forEach((element) => {
-        const foundIdentityForCurrentTable = identities.find(
-          (el) => el.referenced_table_name === element.referenced_table_name,
+      for (const element of foreignKeysConformity) {
+        const identityForCurrentTable = identities.find(
+          (el) => el.referenced_table_name === element.referencedTableName,
         );
 
-        rowsRO.rows.forEach((row) => {
-          const foundIdentityForCurrentValue = foundIdentityForCurrentTable?.identity_columns.find(
-            (el) => el[element.realFKeyName] === row[element.currentFKeyName],
-          );
-          row[element.currentFKeyName] = foundIdentityForCurrentValue ? { ...foundIdentityForCurrentValue } : {};
-        });
-      });
+        if (!identityForCurrentTable) continue;
+
+        const identityColumnsMap = new Map(
+          identityForCurrentTable.identity_columns.map((col) => [col[element.realFKeyName], col]),
+        );
+
+        for (const row of rowsRO.rows) {
+          const identityForCurrentValue = identityColumnsMap.get(row[element.currentFKeyName]);
+          row[element.currentFKeyName] =
+            typeof identityForCurrentValue === 'object' && identityForCurrentValue !== null
+              ? { ...identityForCurrentValue }
+              : {};
+        }
+      }
 
       operationResult = OperationResultStatusEnum.successfully;
       return rowsRO;

From 9c91452d57ab9be7d02965ce20f3e18c9cd54d5b Mon Sep 17 00:00:00 2001
From: Artem Niehrieiev <r.tem@tuta.io>
Date: Wed, 12 Feb 2025 16:20:55 +0000
Subject: [PATCH 2/2] refactor GetTableRows use case to improve identities
 handling with Map for enhanced performance and clarity in foreign key
 processing

---
 .../use-cases/get-table-rows.use.case.ts      | 23 +++++++++----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/backend/src/entities/table/use-cases/get-table-rows.use.case.ts b/backend/src/entities/table/use-cases/get-table-rows.use.case.ts
index df72f079..e127158c 100644
--- a/backend/src/entities/table/use-cases/get-table-rows.use.case.ts
+++ b/backend/src/entities/table/use-cases/get-table-rows.use.case.ts
@@ -229,13 +229,13 @@ export class GetTableRowsUseCase extends AbstractUseCase<GetTableRowsDs, FoundTa
         allow_csv_import: allowCsvImport,
       };
 
-      const identities = [];
+      const identitiesMap = new Map<string, any[]>();
 
       if (tableForeignKeys?.length > 0) {
         for (const foreignKey of tableForeignKeys) {
           const foreignKeysValuesCollection = rowsRO.rows
-            .filter((row) => row[foreignKey.column_name])
-            .map((row) => row[foreignKey.column_name]) as (string | number)[];
+            .map((row) => row[foreignKey.column_name])
+            .filter((value) => value !== undefined) as (string | number)[];
 
           const foreignTableSettings = await this._dbContext.tableSettingsRepository.findTableSettings(
             connectionId,
@@ -250,19 +250,18 @@ export class GetTableRowsUseCase extends AbstractUseCase<GetTableRowsDs, FoundTa
             userEmail,
           );
 
-          if (identities.findIndex((el) => el.referenced_table_name === foreignKey.referenced_table_name) > -1) {
-            identities
-              .find((el) => el.referenced_table_name === foreignKey.referenced_table_name)
-              .identity_columns.push(...identityColumns);
-          } else {
-            identities.push({
-              referenced_table_name: foreignKey.referenced_table_name,
-              identity_columns: identityColumns,
-            });
+          if (!identitiesMap.has(foreignKey.referenced_table_name)) {
+            identitiesMap.set(foreignKey.referenced_table_name, []);
           }
+          identitiesMap.get(foreignKey.referenced_table_name)?.push(...identityColumns);
         }
       }
 
+      const identities = Array.from(identitiesMap, ([referenced_table_name, identity_columns]) => ({
+        referenced_table_name,
+        identity_columns,
+      }));
+
       const foreignKeysConformity = tableForeignKeys.map((key) => ({
         currentFKeyName: key.column_name,
         realFKeyName: key.referenced_column_name,