refactor GetTableRows use case

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);
       }
@@ -228,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,
@@ -249,37 +250,43 @@ 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,
-        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;