플로우 구현

backend-node/src/services/flowDefinitionService.ts

@@ -0,0 +1,171 @@
+/**
+ * 플로우 정의 서비스
+ */
+
+import db from "../database/db";
+import {
+  FlowDefinition,
+  CreateFlowDefinitionRequest,
+  UpdateFlowDefinitionRequest,
+} from "../types/flow";
+
+export class FlowDefinitionService {
+  /**
+   * 플로우 정의 생성
+   */
+  async create(
+    request: CreateFlowDefinitionRequest,
+    userId: string
+  ): Promise<FlowDefinition> {
+    const query = `
+      INSERT INTO flow_definition (name, description, table_name, created_by)
+      VALUES ($1, $2, $3, $4)
+      RETURNING *
+    `;
+
+    const result = await db.query(query, [
+      request.name,
+      request.description || null,
+      request.tableName,
+      userId,
+    ]);
+
+    return this.mapToFlowDefinition(result[0]);
+  }
+
+  /**
+   * 플로우 정의 목록 조회
+   */
+  async findAll(
+    tableName?: string,
+    isActive?: boolean
+  ): Promise<FlowDefinition[]> {
+    let query = "SELECT * FROM flow_definition WHERE 1=1";
+    const params: any[] = [];
+    let paramIndex = 1;
+
+    if (tableName) {
+      query += ` AND table_name = $${paramIndex}`;
+      params.push(tableName);
+      paramIndex++;
+    }
+
+    if (isActive !== undefined) {
+      query += ` AND is_active = $${paramIndex}`;
+      params.push(isActive);
+      paramIndex++;
+    }
+
+    query += " ORDER BY created_at DESC";
+
+    const result = await db.query(query, params);
+    return result.map(this.mapToFlowDefinition);
+  }
+
+  /**
+   * 플로우 정의 단일 조회
+   */
+  async findById(id: number): Promise<FlowDefinition | null> {
+    const query = "SELECT * FROM flow_definition WHERE id = $1";
+    const result = await db.query(query, [id]);
+
+    if (result.length === 0) {
+      return null;
+    }
+
+    return this.mapToFlowDefinition(result[0]);
+  }
+
+  /**
+   * 플로우 정의 수정
+   */
+  async update(
+    id: number,
+    request: UpdateFlowDefinitionRequest
+  ): Promise<FlowDefinition | null> {
+    const fields: string[] = [];
+    const params: any[] = [];
+    let paramIndex = 1;
+
+    if (request.name !== undefined) {
+      fields.push(`name = $${paramIndex}`);
+      params.push(request.name);
+      paramIndex++;
+    }
+
+    if (request.description !== undefined) {
+      fields.push(`description = $${paramIndex}`);
+      params.push(request.description);
+      paramIndex++;
+    }
+
+    if (request.isActive !== undefined) {
+      fields.push(`is_active = $${paramIndex}`);
+      params.push(request.isActive);
+      paramIndex++;
+    }
+
+    if (fields.length === 0) {
+      return this.findById(id);
+    }
+
+    fields.push(`updated_at = NOW()`);
+
+    const query = `
+      UPDATE flow_definition
+      SET ${fields.join(", ")}
+      WHERE id = $${paramIndex}
+      RETURNING *
+    `;
+    params.push(id);
+
+    const result = await db.query(query, params);
+
+    if (result.length === 0) {
+      return null;
+    }
+
+    return this.mapToFlowDefinition(result[0]);
+  }
+
+  /**
+   * 플로우 정의 삭제
+   */
+  async delete(id: number): Promise<boolean> {
+    const query = "DELETE FROM flow_definition WHERE id = $1 RETURNING id";
+    const result = await db.query(query, [id]);
+    return result.length > 0;
+  }
+
+  /**
+   * 테이블 존재 여부 확인
+   */
+  async checkTableExists(tableName: string): Promise<boolean> {
+    const query = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name = $1
+      ) as exists
+    `;
+
+    const result = await db.query(query, [tableName]);
+    return result[0].exists;
+  }
+
+  /**
+   * DB 행을 FlowDefinition 객체로 변환
+   */
+  private mapToFlowDefinition(row: any): FlowDefinition {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      tableName: row.table_name,
+      isActive: row.is_active,
+      createdBy: row.created_by,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+}