Merge remote-tracking branch 'upstream/main'

backend-node/src/services/nodeFlowExecutionService.ts

@@ -2282,6 +2282,7 @@ export class NodeFlowExecutionService {
             UPDATE ${targetTable}
             SET ${setClauses.join(", ")}
             WHERE ${updateWhereConditions}
+            RETURNING *
           `;
 
           logger.info(`🔄 UPDATE 실행:`, {
@@ -2292,8 +2293,14 @@ export class NodeFlowExecutionService {
             values: updateValues,
           });
 
-          await txClient.query(updateSql, updateValues);
+          const updateResult = await txClient.query(updateSql, updateValues);
           updatedCount++;
+          
+          // 🆕 UPDATE 결과를 입력 데이터에 병합 (다음 노드에서 id 등 사용 가능)
+          if (updateResult.rows && updateResult.rows[0]) {
+            Object.assign(data, updateResult.rows[0]);
+            logger.info(`  📦 UPDATE 결과 병합: id=${updateResult.rows[0].id}`);
+          }
         } else {
           // 3-B. 없으면 INSERT
           const columns: string[] = [];
@@ -2340,6 +2347,7 @@ export class NodeFlowExecutionService {
           const insertSql = `
             INSERT INTO ${targetTable} (${columns.join(", ")})
             VALUES (${placeholders})
+            RETURNING *
           `;
 
           logger.info(`➕ INSERT 실행:`, {
@@ -2348,8 +2356,14 @@ export class NodeFlowExecutionService {
             conflictKeyValues,
           });
 
-          await txClient.query(insertSql, values);
+          const insertResult = await txClient.query(insertSql, values);
           insertedCount++;
+          
+          // 🆕 INSERT 결과를 입력 데이터에 병합 (다음 노드에서 id 등 사용 가능)
+          if (insertResult.rows && insertResult.rows[0]) {
+            Object.assign(data, insertResult.rows[0]);
+            logger.info(`  📦 INSERT 결과 병합: id=${insertResult.rows[0].id}`);
+          }
         }
       }
 
@@ -2357,11 +2371,10 @@ export class NodeFlowExecutionService {
         `✅ UPSERT 완료 (내부 DB): ${targetTable}, INSERT ${insertedCount}건, UPDATE ${updatedCount}건`
       );
 
-      return {
-        insertedCount,
-        updatedCount,
-        totalCount: insertedCount + updatedCount,
-      };
+      // 🔥 다음 노드에 전달할 데이터 반환
+      // dataArray에는 Object.assign으로 UPSERT 결과(id 등)가 이미 병합되어 있음
+      // 카운트 정보도 함께 반환하여 기존 호환성 유지
+      return dataArray;
     };
 
     // 🔥 클라이언트가 전달되었으면 사용, 아니면 독립 트랜잭션 생성
@@ -2707,28 +2720,48 @@ export class NodeFlowExecutionService {
       const trueData: any[] = [];
       const falseData: any[] = [];
 
-      inputData.forEach((item: any) => {
-        const results = conditions.map((condition: any) => {
+      // 배열의 각 항목에 대해 조건 평가 (EXISTS 조건은 비동기)
+      for (const item of inputData) {
+        const results: boolean[] = [];
+
+        for (const condition of conditions) {
           const fieldValue = item[condition.field];
 
-          let compareValue = condition.value;
-          if (condition.valueType === "field") {
-            compareValue = item[condition.value];
+          // EXISTS 계열 연산자 처리
+          if (
+            condition.operator === "EXISTS_IN" ||
+            condition.operator === "NOT_EXISTS_IN"
+          ) {
+            const existsResult = await this.evaluateExistsCondition(
+              fieldValue,
+              condition.operator,
+              condition.lookupTable,
+              condition.lookupField,
+              context.companyCode
+            );
+            results.push(existsResult);
             logger.info(
-              `🔄 필드 참조 비교: ${condition.field} (${fieldValue}) vs ${condition.value} (${compareValue})`
+              `🔍 EXISTS 조건: ${condition.field} (${fieldValue}) ${condition.operator} ${condition.lookupTable}.${condition.lookupField} => ${existsResult}`
             );
           } else {
-            logger.info(
-              `📊 고정값 비교: ${condition.field} (${fieldValue}) vs ${compareValue}`
+            // 일반 연산자 처리
+            let compareValue = condition.value;
+            if (condition.valueType === "field") {
+              compareValue = item[condition.value];
+              logger.info(
+                `🔄 필드 참조 비교: ${condition.field} (${fieldValue}) vs ${condition.value} (${compareValue})`
+              );
+            } else {
+              logger.info(
+                `📊 고정값 비교: ${condition.field} (${fieldValue}) vs ${compareValue}`
+              );
+            }
+
+            results.push(
+              this.evaluateCondition(fieldValue, condition.operator, compareValue)
             );
           }
-
-          return this.evaluateCondition(
-            fieldValue,
-            condition.operator,
-            compareValue
-          );
-        });
+        }
 
         const result =
           logic === "OR"
@@ -2740,7 +2773,7 @@ export class NodeFlowExecutionService {
         } else {
           falseData.push(item);
         }
-      });
+      }
 
       logger.info(
         `🔍 조건 필터링 결과: TRUE ${trueData.length}건 / FALSE ${falseData.length}건 (${logic} 로직)`
@@ -2755,27 +2788,46 @@ export class NodeFlowExecutionService {
     }
 
     // 단일 객체인 경우
-    const results = conditions.map((condition: any) => {
+    const results: boolean[] = [];
+
+    for (const condition of conditions) {
       const fieldValue = inputData[condition.field];
 
-      let compareValue = condition.value;
-      if (condition.valueType === "field") {
-        compareValue = inputData[condition.value];
+      // EXISTS 계열 연산자 처리
+      if (
+        condition.operator === "EXISTS_IN" ||
+        condition.operator === "NOT_EXISTS_IN"
+      ) {
+        const existsResult = await this.evaluateExistsCondition(
+          fieldValue,
+          condition.operator,
+          condition.lookupTable,
+          condition.lookupField,
+          context.companyCode
+        );
+        results.push(existsResult);
         logger.info(
-          `🔄 필드 참조 비교: ${condition.field} (${fieldValue}) vs ${condition.value} (${compareValue})`
+          `🔍 EXISTS 조건: ${condition.field} (${fieldValue}) ${condition.operator} ${condition.lookupTable}.${condition.lookupField} => ${existsResult}`
         );
       } else {
-        logger.info(
-          `📊 고정값 비교: ${condition.field} (${fieldValue}) vs ${compareValue}`
+        // 일반 연산자 처리
+        let compareValue = condition.value;
+        if (condition.valueType === "field") {
+          compareValue = inputData[condition.value];
+          logger.info(
+            `🔄 필드 참조 비교: ${condition.field} (${fieldValue}) vs ${condition.value} (${compareValue})`
+          );
+        } else {
+          logger.info(
+            `📊 고정값 비교: ${condition.field} (${fieldValue}) vs ${compareValue}`
+          );
+        }
+
+        results.push(
+          this.evaluateCondition(fieldValue, condition.operator, compareValue)
         );
       }
-
-      return this.evaluateCondition(
-        fieldValue,
-        condition.operator,
-        compareValue
-      );
-    });
+    }
 
     const result =
       logic === "OR"
@@ -2784,7 +2836,7 @@ export class NodeFlowExecutionService {
 
     logger.info(`🔍 조건 평가 결과: ${result} (${logic} 로직)`);
 
-    // ⚠️ 조건 노드는 TRUE/FALSE 브랜치를 위한 특별한 처리 필요
+    // 조건 노드는 TRUE/FALSE 브랜치를 위한 특별한 처리 필요
     // 조건 결과를 저장하고, 원본 데이터는 항상 반환
     // 다음 노드에서 sourceHandle을 기반으로 필터링됨
     return {
@@ -2795,6 +2847,68 @@ export class NodeFlowExecutionService {
     };
   }
 
+  /**
+   * EXISTS_IN / NOT_EXISTS_IN 조건 평가
+   * 다른 테이블에 값이 존재하는지 확인
+   */
+  private static async evaluateExistsCondition(
+    fieldValue: any,
+    operator: string,
+    lookupTable: string,
+    lookupField: string,
+    companyCode?: string
+  ): Promise<boolean> {
+    if (!lookupTable || !lookupField) {
+      logger.warn("⚠️ EXISTS 조건: lookupTable 또는 lookupField가 없습니다");
+      return false;
+    }
+
+    if (fieldValue === null || fieldValue === undefined || fieldValue === "") {
+      logger.info(
+        `⚠️ EXISTS 조건: 필드값이 비어있어 ${operator === "NOT_EXISTS_IN" ? "TRUE" : "FALSE"} 반환`
+      );
+      // 값이 비어있으면: EXISTS_IN은 false, NOT_EXISTS_IN은 true
+      return operator === "NOT_EXISTS_IN";
+    }
+
+    try {
+      // 멀티테넌시: company_code 필터 적용 여부 확인
+      // company_mng 테이블은 제외
+      const hasCompanyCode = lookupTable !== "company_mng" && companyCode;
+
+      let sql: string;
+      let params: any[];
+
+      if (hasCompanyCode) {
+        sql = `SELECT EXISTS(SELECT 1 FROM "${lookupTable}" WHERE "${lookupField}" = $1 AND company_code = $2) as exists_result`;
+        params = [fieldValue, companyCode];
+      } else {
+        sql = `SELECT EXISTS(SELECT 1 FROM "${lookupTable}" WHERE "${lookupField}" = $1) as exists_result`;
+        params = [fieldValue];
+      }
+
+      logger.info(`🔍 EXISTS 쿼리: ${sql}, params: ${JSON.stringify(params)}`);
+
+      const result = await query(sql, params);
+      const existsInTable = result[0]?.exists_result === true;
+
+      logger.info(
+        `🔍 EXISTS 결과: ${fieldValue}이(가) ${lookupTable}.${lookupField}에 ${existsInTable ? "존재함" : "존재하지 않음"}`
+      );
+
+      // EXISTS_IN: 존재하면 true
+      // NOT_EXISTS_IN: 존재하지 않으면 true
+      if (operator === "EXISTS_IN") {
+        return existsInTable;
+      } else {
+        return !existsInTable;
+      }
+    } catch (error: any) {
+      logger.error(`❌ EXISTS 조건 평가 실패: ${error.message}`);
+      return false;
+    }
+  }
+
   /**
    * WHERE 절 생성
    */