@fuzionx/framework 0.1.61 → 0.1.62

package/cli/index.js

@@ -21,10 +21,98 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+
+/**
+ * 프로젝트 CWD 기준 require — CLI가 심링크된 프레임워크 내부에서 실행되므로
+ * 프로젝트의 node_modules를 참조하기 위해 CWD 기반 require 사용
+ * @param {string} pkg - 패키지명
+ * @returns {*} 모듈
+ */
+function _cwdRequire(pkg) {
+    const req = createRequire(path.resolve(process.cwd(), 'package.json'));
+    return req(pkg);
+}
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const TPL_DIR = path.join(__dirname, 'templates');
 
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+//  Knex 컬럼 빌더 — db:sync에서 사용
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Knex table builder에 컬럼 정의를 추가하는 헬퍼
+ *
+ * 모델의 columns 정의 → Knex 스키마 빌더 호출로 변환.
+ * PostgreSQL, MariaDB/MySQL 모두 지원.
+ *
+ * @param {import('knex').Knex.TableBuilder} t - Knex 테이블 빌더
+ * @param {string} col - 컬럼 이름
+ * @param {object} def - 컬럼 정의 객체 ({ type, length, nullable, unique, default })
+ */
+function _knexColumnBuilder(t, col, def) {
+    let c;
+    switch (def.type) {
+        case 'increments':
+            c = t.increments(col);
+            return; // increments는 자동으로 PK + NOT NULL
+        case 'integer':
+            c = t.integer(col);
+            break;
+        case 'bigInteger':
+            c = t.bigInteger(col);
+            break;
+        case 'string':
+            c = t.string(col, def.length || 255);
+            break;
+        case 'text':
+            c = t.text(col);
+            break;
+        case 'boolean':
+            c = t.boolean(col);
+            break;
+        case 'datetime':
+        case 'timestamp':
+            c = t.timestamp(col, { precision: 3 }); // 밀리초 정밀도
+            break;
+        case 'date':
+            c = t.date(col);
+            break;
+        case 'json':
+        case 'jsonb':
+            c = t.jsonb(col); // PostgreSQL JSONB, MariaDB JSON
+            break;
+        case 'float':
+            c = t.float(col);
+            break;
+        case 'decimal':
+            c = t.decimal(col, def.precision || 10, def.scale || 2);
+            break;
+        default:
+            c = t.string(col, def.length || 255);
+    }
+
+    // nullable / not null
+    if (def.nullable) {
+        c.nullable();
+    } else {
+        c.notNullable();
+    }
+
+    // 기본값
+    if (def.default !== undefined) {
+        c.defaultTo(def.default);
+    } else if ((def.type === 'integer' || def.type === 'bigInteger') && !def.nullable) {
+        c.defaultTo(0); // non-nullable integer만 0 기본값 (nullable FK는 NULL 유지)
+    } else if (def.type === 'boolean') {
+        c.defaultTo(false);
+    }
+
+    // unique 제약
+    if (def.unique) c.unique();
+}
+
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 //  Template Engine
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -410,92 +498,396 @@ export async function run(args) {
         return;
     }
 
-    // ── fx db:sync — 모델 ↔ DB 스키마 diff ──
+    // ── fx db:sync — 모델 ↔ DB 스키마 동기화 (멀티 드라이버) ──
     if (command === 'db:sync') {
         try {
             const modelsDir = path.resolve('database/models');
             const files = await fs.readdir(modelsDir);
-            const jsFiles = files.filter(f => f.endsWith('.js'));
+            const jsFiles = files.filter(f => f.endsWith('.js') && !f.startsWith('.'));
             const apply = rest.includes('--apply');
 
-            // fuzionx.yaml에서 DB 경로 읽기
-            let dbPath = './storage/database.sqlite';
-            try {
-                const yaml = await fs.readFile(path.resolve('fuzionx.yaml'), 'utf8');
-                const dbMatch = yaml.match(/database:\s*(.+\.sqlite)/);
-                if (dbMatch) dbPath = dbMatch[1].trim();
-            } catch {}
+            // fuzionx.yaml 파싱 — 드라이버 감지
+            const { default: Config } = await import('../lib/core/Config.js');
+            const config = new Config({});
+            config.loadYaml(path.resolve('fuzionx.yaml'));
+            const dbConfig = config.get('database') || {};
+            const defaultConn = dbConfig.default || 'main';
+            const connConfig = dbConfig.connections?.[defaultConn] || {};
+            const driver = (connConfig.driver || 'sqlite').toLowerCase();
 
-            console.log('\n📊 Model Schema Status:\n');
+            console.log(`\n📊 Model Schema Status (driver: ${driver}):\n`);
             const models = [];
 
             for (const file of jsFiles) {
                 const mod = await import(pathToFileURL(path.join(modelsDir, file)).href);
                 const Model = mod.default;
                 if (!Model) continue;
+                // 모델의 드라이버가 해당 커넥션과 일치하는 것만 처리
+                const modelDriver = (Model.driver || 'sqlite').toLowerCase();
+                if (modelDriver !== driver && modelDriver !== 'postgres' && driver !== 'postgres') continue;
+                if (modelDriver === 'mongodb' || modelDriver === 'mongo') continue; // MongoDB 모델 제외
                 const name = path.basename(file, '.js');
                 const table = Model.table || name.toLowerCase() + 's';
                 const cols = Model.columns || {};
-                models.push({ name, table, cols });
+                const indexes = Model.indexes || [];   // 인덱스 정의 배열
+                models.push({ name, table, cols, indexes, Model });
             }
 
             if (apply) {
-                // SQLite DB 열기
-                const resolvedDbPath = path.resolve(dbPath);
-                await fs.mkdir(path.dirname(resolvedDbPath), { recursive: true });
-                const { default: Database } = await import('better-sqlite3');
-                const db = new Database(resolvedDbPath);
+                if (driver === 'sqlite') {
+                    // ── SQLite ──
+                    const dbPath = connConfig.database || connConfig.path || './storage/database.sqlite';
+                    const resolvedDbPath = path.resolve(dbPath);
+                    await fs.mkdir(path.dirname(resolvedDbPath), { recursive: true });
+                    const { default: Database } = await import('better-sqlite3').catch(() => ({ default: _cwdRequire('better-sqlite3') }));
+                    const db = new Database(resolvedDbPath);
+
+                    for (const { name, table, cols } of models) {
+                        const colDefs = [];
+                        for (const [col, def] of Object.entries(cols)) {
+                            if (def.type === 'increments') {
+                                colDefs.push(`\`${col}\` INTEGER PRIMARY KEY AUTOINCREMENT`);
+                            } else if (def.type === 'integer') {
+                                const dflt = def.default != null ? def.default : 0;
+                                colDefs.push(`\`${col}\` INTEGER${def.nullable ? '' : ' NOT NULL'} DEFAULT ${dflt}`);
+                            } else if (def.type === 'text') {
+                                colDefs.push(`\`${col}\` TEXT${def.nullable ? '' : " NOT NULL DEFAULT ''"}`);
+                            } else if (def.type === 'datetime') {
+                                colDefs.push(`\`${col}\` DATETIME DEFAULT ${def.nullable !== false ? 'NULL' : 'CURRENT_TIMESTAMP'}`);
+                            } else if (def.type === 'boolean') {
+                                const dflt = def.default === true ? 1 : 0;
+                                colDefs.push(`\`${col}\` INTEGER NOT NULL DEFAULT ${dflt}`);
+                            } else if (def.type === 'json') {
+                                colDefs.push(`\`${col}\` TEXT${def.nullable ? '' : " NOT NULL DEFAULT '[]'"}`);
+                            } else {
+                                const unique = def.unique ? ' UNIQUE' : '';
+                                const nullable = def.nullable ? '' : ' NOT NULL';
+                                const dflt = def.default != null ? ` DEFAULT '${def.default}'` : (def.nullable ? '' : " DEFAULT ''");
+                                colDefs.push(`\`${col}\` TEXT${nullable}${dflt}${unique}`);
+                            }
+                        }
+                        const sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (\n  ${colDefs.join(',\n  ')}\n)`;
+                        db.exec(sql);
+
+                        // 누락 컬럼 추가
+                        const existingCols = db.pragma(`table_info(${table})`).map(c => c.name);
+                        let addedCols = 0;
+                        for (const [col, def] of Object.entries(cols)) {
+                            if (existingCols.includes(col)) continue;
+                            let colSql;
+                            if (def.type === 'integer') colSql = `INTEGER${def.nullable ? '' : ' NOT NULL'} DEFAULT ${def.default ?? 0}`;
+                            else if (def.type === 'text') colSql = `TEXT${def.nullable ? '' : " NOT NULL DEFAULT ''"}`;
+                            else if (def.type === 'datetime') colSql = `DATETIME DEFAULT NULL`;
+                            else if (def.type === 'boolean') colSql = `INTEGER NOT NULL DEFAULT ${def.default === true ? 1 : 0}`;
+                            else if (def.type === 'json') colSql = `TEXT${def.nullable ? '' : " NOT NULL DEFAULT '[]'"}`;
+                            else colSql = `TEXT DEFAULT ${def.default != null ? `'${def.default}'` : "''"}`;
+                            db.exec(`ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${colSql}`);
+                            addedCols++;
+                        }
+                        const status = addedCols > 0 ? `✅ synced (+${addedCols} columns)` : '✅ synced';
+                        console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ${status}`);
+                    }
 
-                for (const { name, table, cols } of models) {
-                    const colDefs = [];
-                    for (const [col, def] of Object.entries(cols)) {
-                        if (def.type === 'increments') {
-                            colDefs.push(`\`${col}\` INTEGER PRIMARY KEY AUTOINCREMENT`);
-                        } else if (def.type === 'integer') {
-                            colDefs.push(`\`${col}\` INTEGER NOT NULL DEFAULT 0`);
-                        } else if (def.type === 'text') {
-                            colDefs.push(`\`${col}\` TEXT NOT NULL DEFAULT ''`);
-                        } else if (def.type === 'datetime') {
-                            colDefs.push(`\`${col}\` DATETIME DEFAULT CURRENT_TIMESTAMP`);
-                        } else if (def.type === 'boolean') {
-                            colDefs.push(`\`${col}\` INTEGER NOT NULL DEFAULT 0`);
+                    // ── SQLite 인덱스 동기화 ──
+                    for (const { name, table, indexes } of models) {
+                        if (!indexes || indexes.length === 0) continue;
+                        for (const idx of indexes) {
+                            if (!idx.columns || idx.columns.length === 0) continue;
+                            // 인덱스 이름 자동 생성: idx_{table}_{col1}_{col2}
+                            const idxName = idx.name || `idx_${table}_${idx.columns.join('_')}`;
+                            const colList = idx.columns.map(c => `\`${c}\``).join(', ');
+                            const uniqueStr = idx.unique ? 'UNIQUE ' : '';
+                            const sql = `CREATE ${uniqueStr}INDEX IF NOT EXISTS \`${idxName}\` ON \`${table}\` (${colList})`;
+                            try {
+                                db.exec(sql);
+                            } catch (e) {
+                                // 이미 존재하면 무시
+                            }
+                        }
+                        console.log(`  ${name.padEnd(20)} indexes: ${indexes.length} synced`);
+                    }
+
+                    db.close();
+                    console.log(`\n  Database: ${path.resolve(connConfig.database || './storage/database.sqlite')}`);
+
+                } else if (driver === 'postgres' || driver === 'postgresql' || driver === 'mariadb' || driver === 'mysql') {
+                    // ── Knex 기반 (PostgreSQL / MariaDB) ──
+                    const knexModule = _cwdRequire('knex');
+                    const knexInit = typeof knexModule === 'function' ? knexModule : knexModule.knex || knexModule.default;
+                    const client = (driver === 'postgres' || driver === 'postgresql') ? 'pg' : 'mysql2';
+                    const db = knexInit({
+                        client,
+                        connection: {
+                            host: connConfig.host || '127.0.0.1',
+                            port: connConfig.port || (client === 'pg' ? 5432 : 3306),
+                            user: connConfig.user || (client === 'pg' ? 'postgres' : 'root'),
+                            password: connConfig.password || '',
+                            database: connConfig.database || '',
+                            charset: connConfig.charset || undefined,
+                        },
+                        pool: connConfig.pool || { min: 2, max: 10 },
+                    });
+
+                    // DDL SQL 캡처 — migrations 로그용
+                    const ddlLog = [];
+                    db.on('query', (data) => {
+                        const sql = (data.sql || '').trim();
+                        // DDL 문만 기록 (SELECT/정보조회 제외)
+                        if (/^(CREATE|ALTER|DROP)/i.test(sql)) {
+                            // 바인딩 치환 (읽기 편하게)
+                            let resolved = sql;
+                            if (data.bindings && data.bindings.length > 0) {
+                                for (const b of data.bindings) {
+                                    resolved = resolved.replace('?', typeof b === 'string' ? `'${b}'` : String(b));
+                                }
+                            }
+                            ddlLog.push(resolved);
+                        }
+                    });
+
+                    for (const { name, table, cols } of models) {
+                        const exists = await db.schema.hasTable(table);
+                        if (!exists) {
+                            // 테이블 생성
+                            await db.schema.createTable(table, (t) => {
+                                for (const [col, def] of Object.entries(cols)) {
+                                    _knexColumnBuilder(t, col, def);
+                                }
+                            });
+                            console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ✅ created`);
                         } else {
-                            // string, etc.
-                            const unique = def.unique ? ' UNIQUE' : '';
-                            const dflt = def.default != null ? ` DEFAULT '${def.default}'` : " DEFAULT ''";
-                            colDefs.push(`\`${col}\` TEXT NOT NULL${dflt}${unique}`);
+                            // 누락 컬럼 추가
+                            let addedCols = 0;
+                            for (const [col, def] of Object.entries(cols)) {
+                                const hasCol = await db.schema.hasColumn(table, col);
+                                if (!hasCol) {
+                                    await db.schema.alterTable(table, (t) => {
+                                        _knexColumnBuilder(t, col, def);
+                                    });
+                                    addedCols++;
+                                }
+                            }
+                            const status = addedCols > 0 ? `✅ synced (+${addedCols} columns)` : '✅ synced';
+                            console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ${status}`);
                         }
                     }
-                    const sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (\n  ${colDefs.join(',\n  ')}\n)`;
-                    db.exec(sql);
-
-                    // ── 기존 테이블에 누락된 컬럼 추가 (ALTER TABLE) ──
-                    const existingCols = db.pragma(`table_info(${table})`).map(c => c.name);
-                    let addedCols = 0;
-                    for (const [col, def] of Object.entries(cols)) {
-                        if (existingCols.includes(col)) continue;
-
-                        let colSql;
-                        if (def.type === 'integer') {
-                            colSql = `INTEGER NOT NULL DEFAULT 0`;
-                        } else if (def.type === 'text') {
-                            colSql = `TEXT NOT NULL DEFAULT ''`;
-                        } else if (def.type === 'datetime') {
-                            colSql = `DATETIME DEFAULT NULL`;
-                        } else if (def.type === 'boolean') {
-                            colSql = `INTEGER NOT NULL DEFAULT 0`;
+
+                    // ── Knex 인덱스 동기화 (PostgreSQL / MariaDB) ──
+                    for (const { name, table, indexes } of models) {
+                        if (!indexes || indexes.length === 0) continue;
+                        let createdCount = 0;
+                        for (const idx of indexes) {
+                            if (!idx.columns || idx.columns.length === 0) continue;
+                            const idxName = idx.name || `idx_${table}_${idx.columns.join('_')}`;
+                            try {
+                                // 인덱스 존재 여부 확인
+                                const checkSql = client === 'pg'
+                                    ? `SELECT 1 FROM pg_indexes WHERE tablename = ? AND indexname = ?`
+                                    : `SELECT 1 FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ? LIMIT 1`;
+                                const exists = await db.raw(checkSql, [table, idxName]);
+                                const hasIndex = client === 'pg'
+                                    ? (exists.rows && exists.rows.length > 0)
+                                    : (Array.isArray(exists[0]) ? exists[0].length > 0 : exists.length > 0);
+                                if (hasIndex) continue; // 이미 존재하면 스킵
+
+                                await db.schema.alterTable(table, (t) => {
+                                    if (idx.unique) {
+                                        t.unique(idx.columns, { indexName: idxName });
+                                    } else {
+                                        t.index(idx.columns, idxName);
+                                    }
+                                });
+                                createdCount++;
+                            } catch (e) {
+                                // 이미 존재하는 경우 무시
+                                if (!e.message.includes('already exists')) {
+                                    console.warn(`  ⚠️  Index ${idxName}: ${e.message}`);
+                                }
+                            }
+                        }
+                        if (createdCount > 0) {
+                            console.log(`  ${name.padEnd(20)} indexes: +${createdCount} created`);
+                        }
+                    }
+
+                    // ── Knex FK 제약 동기화 (PostgreSQL / MariaDB) ──
+                    // 모델명 → 테이블명 매핑 (relation resolve용)
+                    const modelTableMap = new Map();
+                    for (const { name, table, Model } of models) {
+                        modelTableMap.set(name, { table, Model });
+                    }
+
+                    let fkCreatedTotal = 0;
+                    for (const { name, table, Model } of models) {
+                        const relations = Model.relations || {};
+                        const columns = Model.columns || {};
+
+                        for (const [relName, rel] of Object.entries(relations)) {
+                            // belongsTo만 FK 생성 대상 (현재 테이블에 FK 컬럼이 있음)
+                            if (rel.type !== 'belongsTo') continue;
+
+                            const foreignKey = rel.foreignKey;
+                            if (!foreignKey) continue;
+
+                            // 대상 모델 → 테이블명 resolve
+                            const targetModelName = typeof rel.model === 'string' ? rel.model : rel.model?.name;
+                            const targetInfo = modelTableMap.get(targetModelName);
+                            if (!targetInfo) continue; // 대상 모델을 찾을 수 없으면 스킵
+
+                            const targetTable = targetInfo.table;
+                            const targetKey = rel.ownerKey || 'id'; // 대상 테이블의 참조 키
+
+                            // FK 제약명: fk_{테이블}_{FK컬럼}
+                            const fkName = `fk_${table}_${foreignKey}`;
+
+                            try {
+                                // FK 이미 존재하는지 확인
+                                const checkSql = client === 'pg'
+                                    ? `SELECT 1 FROM information_schema.table_constraints WHERE constraint_type = 'FOREIGN KEY' AND table_name = ? AND constraint_name = ?`
+                                    : `SELECT 1 FROM information_schema.TABLE_CONSTRAINTS WHERE CONSTRAINT_TYPE = 'FOREIGN KEY' AND TABLE_NAME = ? AND CONSTRAINT_NAME = ? AND TABLE_SCHEMA = DATABASE()`;
+                                const fkExists = await db.raw(checkSql, [table, fkName]);
+                                const hasFk = client === 'pg'
+                                    ? (fkExists.rows && fkExists.rows.length > 0)
+                                    : (Array.isArray(fkExists[0]) ? fkExists[0].length > 0 : fkExists.length > 0);
+                                if (hasFk) continue; // 이미 존재하면 스킵
+
+                                // onDelete 결정: relation에 명시 > nullable이면 SET NULL > 아니면 CASCADE
+                                const colDef = columns[foreignKey] || {};
+                                const onDelete = rel.onDelete || (colDef.nullable ? 'SET NULL' : 'CASCADE');
+
+                                await db.schema.alterTable(table, (t) => {
+                                    t.foreign(foreignKey, fkName)
+                                        .references(targetKey)
+                                        .inTable(targetTable)
+                                        .onDelete(onDelete);
+                                });
+                                fkCreatedTotal++;
+                            } catch (e) {
+                                if (!e.message.includes('already exists')) {
+                                    console.warn(`  ⚠️  FK ${fkName}: ${e.message}`);
+                                }
+                            }
+                        }
+                    }
+                    if (fkCreatedTotal > 0) {
+                        console.log(`\n  🔗 Foreign Keys: +${fkCreatedTotal} created`);
+                    }
+
+                    // ── Migration SQL 파일 저장 (DDL 변경이 있을 때만) ──
+                    if (ddlLog.length > 0) {
+                        const migrationsDir = path.resolve('database/migrations');
+                        await fs.mkdir(migrationsDir, { recursive: true });
+                        const now = new Date();
+                        const ts = now.toISOString()
+                            .replace(/[-:]/g, '')   // 20260404T110800
+                            .replace('T', '_')       // 20260404_110800
+                            .slice(0, 15);           // 20260404_110800
+                        const fileName = `${ts}_sync.sql`;
+                        const header = [
+                            `-- FuzionX db:sync migration`,
+                            `-- Generated: ${now.toISOString()}`,
+                            `-- Driver: ${driver} (${connConfig.host}:${connConfig.port}/${connConfig.database})`,
+                            `-- ──────────────────────────────────────`,
+                            '',
+                        ].join('\n');
+                        const body = ddlLog.map(sql => `${sql};`).join('\n\n');
+                        await fs.writeFile(path.join(migrationsDir, fileName), header + body + '\n');
+                        console.log(`\n  📝 Migration saved: database/migrations/${fileName} (${ddlLog.length} statements)`);
+                    }
+
+                    await db.destroy();
+                    console.log(`\n  Database: ${driver}://${connConfig.host}:${connConfig.port}/${connConfig.database}`);
+
+                }
+
+                // ── MongoDB 인덱스 동기화 ──
+                const mongoModels = [];
+                for (const file of jsFiles) {
+                    const mod = await import(pathToFileURL(path.join(modelsDir, file)).href);
+                    const Model = mod.default;
+                    if (!Model) continue;
+                    const modelDriver = (Model.driver || 'sqlite').toLowerCase();
+                    if (modelDriver !== 'mongodb' && modelDriver !== 'mongo') continue;
+                    const name = path.basename(file, '.js');
+                    const collection = Model.table || Model.collection || name.toLowerCase() + 's';
+                    const indexes = Model.indexes || [];
+                    if (indexes.length > 0) {
+                        mongoModels.push({ name, collection, indexes, Model });
+                    }
+                }
+
+                if (mongoModels.length > 0) {
+                    // MongoDB 연결 설정 읽기
+                    const mongoConfig = dbConfig.connections?.mongo || dbConfig.connections?.mongodb || {};
+                    const host = mongoConfig.host || '127.0.0.1';
+                    const port = mongoConfig.port || 27017;
+                    const dbName = mongoConfig.database || 'fuzionx';
+                    const authSource = mongoConfig.authSource || dbName;
+                    // 인증 URI 구성 (user/password가 있으면 포함)
+                    let mongoUri = mongoConfig.uri || mongoConfig.url;
+                    if (!mongoUri) {
+                        if (mongoConfig.user && mongoConfig.password) {
+                            mongoUri = `mongodb://${encodeURIComponent(String(mongoConfig.user))}:${encodeURIComponent(String(mongoConfig.password))}@${host}:${port}/${dbName}?authSource=${authSource}`;
                         } else {
-                            const dflt = def.default != null ? `'${def.default}'` : "''";
-                            colSql = `TEXT DEFAULT ${dflt}`;
+                            mongoUri = `mongodb://${host}:${port}/${dbName}`;
                         }
-                        db.exec(`ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${colSql}`);
-                        addedCols++;
                     }
-                    const status = addedCols > 0 ? `✅ synced (+${addedCols} columns)` : '✅ synced';
-                    console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ${status}`);
+                    const mongoDbName = dbName;
+
+                    try {
+                        const { MongoClient } = await import('mongodb').catch(() => ({ MongoClient: _cwdRequire('mongodb').MongoClient }));
+                        const mongoClient = new MongoClient(mongoUri, { serverSelectionTimeoutMS: 5000 });
+                        await mongoClient.connect();
+                        const mongoDB = mongoClient.db(mongoDbName);
+
+                        console.log(`\n📊 MongoDB Index Sync:\n`);
+                        for (const { name, collection, indexes } of mongoModels) {
+                            const coll = mongoDB.collection(collection);
+                            let createdCount = 0;
+                            // 기존 인덱스 목록 조회
+                            const existingIndexes = await coll.indexes().catch(() => []);
+                            const existingNames = existingIndexes.map(i => i.name);
+
+                            for (const idx of indexes) {
+                                if (!idx.columns) continue;
+                                // columns가 객체({ field: 1 })인지 배열(['field'])인지 판별
+                                const isObject = !Array.isArray(idx.columns);
+                                const columnKeys = isObject ? Object.keys(idx.columns) : idx.columns;
+                                if (columnKeys.length === 0) continue;
+                                const idxName = idx.name || `idx_${columnKeys.join('_')}`;
+                                if (existingNames.includes(idxName)) continue; // 이미 존재
+
+                                // MongoDB 인덱스 키 객체 생성 { field1: 1, field2: -1 }
+                                let keys;
+                                if (isObject) {
+                                    keys = idx.columns; // 이미 { field: 1, field: -1 } 형태
+                                } else {
+                                    keys = {};
+                                    for (const col of idx.columns) {
+                                        keys[col] = idx.descending ? -1 : 1;
+                                    }
+                                }
+                                const options = { name: idxName };
+                                if (idx.unique) options.unique = true;
+                                if (idx.sparse) options.sparse = true;
+                                if (idx.ttl != null) options.expireAfterSeconds = idx.ttl;
+
+                                try {
+                                    await coll.createIndex(keys, options);
+                                    createdCount++;
+                                } catch (e) {
+                                    console.warn(`  ⚠️  ${collection}.${idxName}: ${e.message}`);
+                                }
+                            }
+                            const status = createdCount > 0 ? `+${createdCount} created` : 'synced';
+                            console.log(`  ${name.padEnd(20)} collection: ${collection.padEnd(20)} indexes: ${indexes.length}  ✅ ${status}`);
+                        }
+
+                        await mongoClient.close();
+                    } catch (mongoErr) {
+                        console.warn(`  ⚠️  MongoDB 인덱스 동기화 실패: ${mongoErr.message}`);
+                    }
                 }
-                db.close();
-                console.log(`\n  Database: ${path.resolve(dbPath)}`);
             } else {
                 for (const { name, table, cols } of models) {
                     console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ⏳ pending`);
@@ -507,6 +899,71 @@ export async function run(args) {
         return;
     }
 
+    // ── fx db:seed — 시드 데이터 투입 ──
+    if (command === 'db:seed') {
+        try {
+            const seedDir = path.resolve('database/seeds');
+            const indexPath = path.join(seedDir, 'index.js');
+            try {
+                await fs.access(indexPath);
+            } catch {
+                console.error('❌ database/seeds/index.js 파일이 없습니다.');
+                process.exit(1);
+            }
+
+            // DB 연결 부트 — ConnectionManager 초기화
+            const { default: Config } = await import('../lib/core/Config.js');
+            const ConnectionManager = (await import('../lib/database/ConnectionManager.js')).default;
+
+            const config = new Config({});
+            config.loadYaml(path.resolve('fuzionx.yaml'));
+            const dbConfig = config.get('database');
+
+            if (dbConfig) {
+                if (!dbConfig.connections) {
+                    const connections = {};
+                    for (const [key, val] of Object.entries(dbConfig)) {
+                        if (key !== 'default' && typeof val === 'object' && val !== null) {
+                            connections[key] = val;
+                        }
+                    }
+                    if (Object.keys(connections).length > 0) {
+                        dbConfig.connections = connections;
+                        if (!dbConfig.default) dbConfig.default = Object.keys(connections)[0];
+                    }
+                }
+                const cm = new ConnectionManager();
+                cm.configure(dbConfig);
+
+                // CLI 상대경로와 모델의 @fuzionx/framework 경로가 ESM에서 별개 모듈로 캐시됨.
+                // 모델이 실제 사용하는 SqlModel에 ConnectionManager를 주입하기 위해
+                // 모델 디렉토리에서 첫 번째 모델을 import하여 그 부모 클래스 체인에 주입.
+                const modelsDir = path.resolve('database/models');
+                const modelFiles = (await fs.readdir(modelsDir)).filter(f => f.endsWith('.js'));
+                if (modelFiles.length > 0) {
+                    const firstModel = (await import(pathToFileURL(path.join(modelsDir, modelFiles[0])).href)).default;
+                    if (firstModel && typeof firstModel.setConnectionManager === 'function') {
+                        firstModel.setConnectionManager(cm);
+                    }
+                }
+
+                // CLI 자체 SqlModel에도 주입 (혹시 직접 참조하는 경우 대비)
+                const SqlModel = (await import('../lib/database/SqlModel.js')).default;
+                SqlModel.setConnectionManager(cm);
+            }
+
+            // 시드 실행
+            const seedModule = await import(pathToFileURL(indexPath).href);
+            const runSeeds = seedModule.runSeeds || seedModule.default;
+            if (typeof runSeeds === 'function') {
+                await runSeeds();
+            } else {
+                console.error('❌ database/seeds/index.js에 runSeeds 함수가 없습니다.');
+            }
+        } catch (err) { console.error('db:seed error:', err.message, err.stack); }
+        return;
+    }
+
     console.log(`
   npx create-fuzionx <name>         Create new project
   fx make:app --type=ssr|spa [--name=<appName>]  Create app
@@ -529,5 +986,6 @@ export async function run(args) {
   fx routes                         Print route table
   fx config                         Print fuzionx.yaml
   fx db:sync                        Sync models → DB (--apply)
+  fx db:seed                        Run seed files (database/seeds)
 `);
 }

package/cli/templates/make/app-spa/views/default/spa/package.json

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@fuzionx/player": "^0.1.61",
+    "@fuzionx/player": "^0.1.62",
     "pinia": "^3.0.4",
     "vue": "^3.5.0",
     "vue-router": "^4.5.0"