@fuzionx/framework 0.1.42 → 0.1.43

package/lib/core/Config.js

@@ -62,21 +62,94 @@ export default class Config {
 
     /**
      * 간이 YAML 파서 — 외부 의존 없이 fuzionx.yaml 구조 파싱.
-     * 지원: 중첩 객체, 문자열, 숫자, boolean, 배열(인라인), 인용 문자열.
+     * 지원: 중첩 객체, 문자열, 숫자, boolean, 배열(인라인/블록), 인용 문자열.
+     * Windows(\r\n) / Unix(\n) 줄바꿈 모두 지원.
      * @param {string} content
      * @returns {object}
      */
     static parseYaml(content) {
         const result = {};
-        const lines = content.split('\n');
+        // Windows \r\n → \n 정규화 (정규식 $, . 호환)
+        const lines = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+        // stack: { indent, obj, lastKey? }
         const stack = [{ indent: -1, obj: result }];
 
         for (const rawLine of lines) {
-            // 주석/빈 줄 무시
-            const line = rawLine.replace(/#.*$/, '');
+            // 인용부호 바깥의 # 주석만 제거 (문자열 안의 # 보존)
+            const line = Config._stripInlineComment(rawLine);
             if (!line.trim()) continue;
 
             const indent = line.search(/\S/);
+
+            // ── YAML 블록 배열 항목: "- value" 또는 "- key: value" ──
+            const listMatch = line.match(/^(\s*)-\s+(.+)$/);
+            if (listMatch) {
+                const listIndent = listMatch[1].length;
+
+                // 스택에서 현재 indent보다 깊은 레벨 제거 (배열은 유지)
+                while (stack.length > 1) {
+                    const top = stack[stack.length - 1];
+                    if (Array.isArray(top.obj) && top.indent === listIndent) break;
+                    if (top.indent >= listIndent) {
+                        stack.pop();
+                    } else {
+                        break;
+                    }
+                }
+
+                // 부모 찾기 — 배열이면 직접 사용, 아니면 lastKey를 배열로 변환
+                const top = stack[stack.length - 1];
+                let arr;
+                if (Array.isArray(top.obj)) {
+                    arr = top.obj;
+                } else {
+                    // lastKey 탐색: 현재 top → 상위 스택 순서로 찾기
+                    // (빈 값 키 origins: → {} 가 스택에 있으면 lastKey=undefined,
+                    //  이 경우 부모의 lastKey가 "origins")
+                    let foundIdx = -1;
+                    let foundKey = null;
+                    let foundObj = null;
+                    for (let si = stack.length - 1; si >= 0; si--) {
+                        if (stack[si].lastKey !== undefined) {
+                            foundIdx = si;
+                            foundKey = stack[si].lastKey;
+                            foundObj = stack[si].obj;
+                            // 배열이 아닌 빈 객체가 이 키 아래 있으면 그게 배열로 바뀌어야 함
+                            const target = Array.isArray(foundObj)
+                                ? foundObj[foundObj.length - 1]
+                                : foundObj;
+                            if (target && typeof target[foundKey] !== undefined) {
+                                foundObj = target;
+                            }
+                            break;
+                        }
+                    }
+                    if (foundKey === null) continue;
+                    if (!Array.isArray(foundObj[foundKey])) {
+                        foundObj[foundKey] = [];
+                    }
+                    arr = foundObj[foundKey];
+                    // 기존 빈 객체 스택 제거 후 배열로 교체
+                    while (stack.length > foundIdx + 1) stack.pop();
+                    stack.push({ indent: listIndent, obj: arr });
+                }
+
+                const itemContent = listMatch[2].trim();
+                // "- key: value" 형태인지 확인
+                const kvMatch = itemContent.match(/^(?:(["'])([^"']+)\1|([-\w.]+))\s*:\s*(.+)$/);
+                if (kvMatch) {
+                    const k = kvMatch[2] || kvMatch[3];
+                    const v = Config._parseYamlValue(kvMatch[4].trim());
+                    const obj = { [k]: v };
+                    arr.push(obj);
+                    stack.push({ indent: listIndent + 2, obj, lastKey: k });
+                } else {
+                    arr.push(Config._parseYamlValue(itemContent));
+                }
+                continue;
+            }
+
+            // ── 키: 값 파싱 ──
             // 키: unquoted ([-\w.]+) 또는 quoted ("..." / '...')
             const match = line.match(/^(\s*)(?:(["'])([^"']+)\2|([-\w.]+))\s*:\s*(.*)$/);
             if (!match) continue;
@@ -89,22 +162,50 @@ export default class Config {
                 stack.pop();
             }
 
-            const parent = stack[stack.length - 1].obj;
+            const top = stack[stack.length - 1];
+            // 배열 안의 마지막 객체에 키 추가 (- key: value 후속 키)
+            const target = Array.isArray(top.obj) ? top.obj[top.obj.length - 1] : top.obj;
             const value = rawValue.trim();
 
             if (!value) {
                 // 하위 객체 시작
-                parent[key] = {};
-                stack.push({ indent, obj: parent[key] });
+                target[key] = {};
+                stack.push({ indent, obj: target[key], lastKey: undefined });
+                // lastKey를 부모에 설정 (배열 전환 시 필요)
+                const parentIdx = stack.length - 2;
+                if (parentIdx >= 0) {
+                    stack[parentIdx].lastKey = key;
+                }
             } else {
                 // 값 파싱
-                parent[key] = Config._parseYamlValue(value);
+                target[key] = Config._parseYamlValue(value);
+                top.lastKey = key;
             }
         }
 
         return result;
     }
 
+    /**
+     * 인라인 주석 제거 — 인용부호 안의 # 보존
+     * @param {string} line
+     * @returns {string}
+     * @private
+     */
+    static _stripInlineComment(line) {
+        let inSingle = false;
+        let inDouble = false;
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (ch === "'" && !inDouble) inSingle = !inSingle;
+            else if (ch === '"' && !inSingle) inDouble = !inDouble;
+            else if (ch === '#' && !inSingle && !inDouble) {
+                return line.slice(0, i);
+            }
+        }
+        return line;
+    }
+
     /**
      * YAML 값 파싱 (문자열, 숫자, boolean, 배열)
      * @private
@@ -121,7 +222,9 @@ export default class Config {
 
         // 인라인 배열 [a, b, c]
         if (raw.startsWith('[') && raw.endsWith(']')) {
-            return raw.slice(1, -1).split(',').map(s => Config._parseYamlValue(s.trim()));
+            const inner = raw.slice(1, -1).trim();
+            if (!inner) return [];
+            return inner.split(',').map(s => Config._parseYamlValue(s.trim()));
         }
 
         // 숫자

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzionx/framework",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "type": "module",
   "description": "Full-stack MVC framework built on @fuzionx/core — Controller, Service, Model, Middleware, DI, EventBus",
   "main": "index.js",
@@ -34,7 +34,7 @@
     "url": "https://github.com/saytohenry/fuzionx"
   },
   "dependencies": {
-    "@fuzionx/core": "^0.1.42",
+    "@fuzionx/core": "^0.1.43",
     "better-sqlite3": "^12.8.0",
     "knex": "^3.2.5",
     "mongoose": "^9.3.2",