@fuzionx/framework 0.1.73 → 0.1.75

package/cli/index.js

@@ -103,9 +103,15 @@ function _knexColumnBuilder(t, col, def) {
         c.notNullable();
     }
 
-    // 기본값
+    // 기본값 — SQL 함수 표현식(now() 등)은 knex.raw()로 전달
     if (def.default !== undefined) {
-        c.defaultTo(def.default);
+        const val = def.default;
+        if (typeof val === 'string' && /^\w+\(.*\)$/.test(val)) {
+            // SQL 함수 표현식 (now(), uuid_generate_v4() 등)
+            c.defaultTo(t.client.raw(val));
+        } else {
+            c.defaultTo(val);
+        }
     } 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') {
@@ -902,6 +908,197 @@ export async function run(args) {
         return;
     }
 
+    // ── fx db:fresh — 테이블 전체 삭제 → 재생성 → 시드 ──
+    // ── fx db:reset — db:fresh 별칭 ──
+    if (command === 'db:fresh' || command === 'db:reset') {
+        const confirm = rest.includes('--confirm');
+        const skipSeed = rest.includes('--no-seed');
+
+        if (!confirm) {
+            console.log(`
+  ⚠️  이 명령은 모든 테이블을 삭제하고 재생성합니다.
+  데이터가 모두 삭제됩니다!
+
+  실행하려면 --confirm 플래그를 추가하세요:
+    fx ${command} --confirm
+
+  시드를 건너뛰려면:
+    fx ${command} --confirm --no-seed
+`);
+            process.exit(0);
+        }
+
+        try {
+            // ── 1. DB 설정 로드 ──
+            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🔥 DB Fresh Start (driver: ${driver})\n`);
+
+            if (driver === 'sqlite') {
+                // SQLite — DB 파일 삭제
+                const dbPath = path.resolve(connConfig.database || connConfig.path || './storage/database.sqlite');
+                try {
+                    await fs.unlink(dbPath);
+                    console.log(`  🗑️  Deleted: ${dbPath}`);
+                } catch (e) {
+                    if (e.code !== 'ENOENT') throw e;
+                    console.log(`  ⚠️  SQLite file not found — clean state.`);
+                }
+
+            } else if (driver === 'postgres' || driver === 'postgresql') {
+                // PostgreSQL — 모든 테이블 CASCADE DROP
+                const knexModule = _cwdRequire('knex');
+                const knexInit = typeof knexModule === 'function' ? knexModule : knexModule.knex || knexModule.default;
+                const db = knexInit({
+                    client: 'pg',
+                    connection: {
+                        host: connConfig.host || '127.0.0.1',
+                        port: connConfig.port || 5432,
+                        user: connConfig.user || 'postgres',
+                        password: connConfig.password || '',
+                        database: connConfig.database || '',
+                    },
+                    pool: { min: 1, max: 3 },
+                });
+
+                // public 스키마의 모든 테이블 조회
+                const result = await db.raw(`
+                    SELECT tablename FROM pg_tables
+                    WHERE schemaname = 'public'
+                    ORDER BY tablename
+                `);
+                const tables = result.rows.map(r => r.tablename);
+
+                if (tables.length === 0) {
+                    console.log('  ⚠️  테이블이 없습니다 — clean state.');
+                } else {
+                    console.log(`  🗑️  ${tables.length}개 테이블 삭제 중...\n`);
+                    for (const table of tables) {
+                        await db.raw(`DROP TABLE IF EXISTS "${table}" CASCADE`);
+                        console.log(`    ✗ ${table}`);
+                    }
+                    console.log(`\n  ✅ ${tables.length}개 테이블 삭제 완료.`);
+                }
+
+                // 시퀀스도 정리
+                const seqResult = await db.raw(`
+                    SELECT relname FROM pg_class
+                    WHERE relkind = 'S' AND relnamespace = (
+                        SELECT oid FROM pg_namespace WHERE nspname = 'public'
+                    )
+                `);
+                const sequences = seqResult.rows.map(r => r.relname);
+                if (sequences.length > 0) {
+                    for (const seq of sequences) {
+                        await db.raw(`DROP SEQUENCE IF EXISTS "${seq}" CASCADE`);
+                    }
+                    console.log(`  🔗 ${sequences.length}개 시퀀스 삭제.`);
+                }
+
+                await db.destroy();
+
+            } else if (driver === 'mariadb' || driver === 'mysql') {
+                // MariaDB/MySQL — 모든 테이블 CASCADE DROP
+                const knexModule = _cwdRequire('knex');
+                const knexInit = typeof knexModule === 'function' ? knexModule : knexModule.knex || knexModule.default;
+                const db = knexInit({
+                    client: 'mysql2',
+                    connection: {
+                        host: connConfig.host || '127.0.0.1',
+                        port: connConfig.port || 3306,
+                        user: connConfig.user || 'root',
+                        password: connConfig.password || '',
+                        database: connConfig.database || '',
+                    },
+                    pool: { min: 1, max: 3 },
+                });
+
+                const [rows] = await db.raw(`SHOW TABLES`);
+                const dbName = connConfig.database || '';
+                const tables = rows.map(r => Object.values(r)[0]);
+
+                if (tables.length === 0) {
+                    console.log('  ⚠️  테이블이 없습니다 — clean state.');
+                } else {
+                    await db.raw('SET FOREIGN_KEY_CHECKS = 0');
+                    console.log(`  🗑️  ${tables.length}개 테이블 삭제 중...\n`);
+                    for (const table of tables) {
+                        await db.raw(`DROP TABLE IF EXISTS \`${table}\``);
+                        console.log(`    ✗ ${table}`);
+                    }
+                    await db.raw('SET FOREIGN_KEY_CHECKS = 1');
+                    console.log(`\n  ✅ ${tables.length}개 테이블 삭제 완료.`);
+                }
+
+                await db.destroy();
+            }
+
+            // ── 2. MongoDB 컬렉션 삭제 ──
+            const mongoConfig = dbConfig.connections?.mongo || dbConfig.connections?.mongodb;
+            if (mongoConfig) {
+                try {
+                    const host = mongoConfig.host || '127.0.0.1';
+                    const port = mongoConfig.port || 27017;
+                    const dbName = mongoConfig.database || 'fuzionx';
+                    const authSource = mongoConfig.authSource || dbName;
+                    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 {
+                            mongoUri = `mongodb://${host}:${port}/${dbName}`;
+                        }
+                    }
+
+                    const { MongoClient } = await import('mongodb').catch(() => ({ MongoClient: _cwdRequire('mongodb').MongoClient }));
+                    const mongoClient = new MongoClient(mongoUri, { serverSelectionTimeoutMS: 5000 });
+                    await mongoClient.connect();
+                    const mongoDB = mongoClient.db(dbName);
+
+                    const collections = await mongoDB.listCollections().toArray();
+                    const userCollections = collections.filter(c => !c.name.startsWith('system.'));
+
+                    if (userCollections.length > 0) {
+                        console.log(`\n  🗑️  MongoDB: ${userCollections.length}개 컬렉션 삭제 중...\n`);
+                        for (const coll of userCollections) {
+                            await mongoDB.dropCollection(coll.name).catch(() => {});
+                            console.log(`    ✗ ${coll.name}`);
+                        }
+                        console.log(`\n  ✅ MongoDB ${userCollections.length}개 컬렉션 삭제 완료.`);
+                    } else {
+                        console.log('\n  ⚠️  MongoDB 컬렉션이 없습니다.');
+                    }
+
+                    await mongoClient.close();
+                } catch (mongoErr) {
+                    console.warn(`  ⚠️  MongoDB 초기화 실패: ${mongoErr.message}`);
+                }
+            }
+
+            // ── 3. 재생성: db:sync --apply ──
+            console.log('\n\n📊 테이블 재생성 (db:sync --apply)...\n');
+            const { execSync } = await import('node:child_process');
+            execSync('npx fx db:sync --apply', { stdio: 'inherit', cwd: process.cwd() });
+
+            // ── 4. 시드 투입 ──
+            if (!skipSeed) {
+                console.log('\n\n🌱 시드 데이터 투입 (db:seed)...\n');
+                execSync('npx fx db:seed', { stdio: 'inherit', cwd: process.cwd() });
+            }
+
+            console.log('\n✅ DB Fresh 완료!\n');
+        } catch (err) {
+            console.error('db:fresh error:', err.message, err.stack);
+        }
+        process.exit(0);
+    }
+
     // ── fx db:seed — 시드 데이터 투입 ──
     if (command === 'db:seed') {
         try {
@@ -953,6 +1150,17 @@ export async function run(args) {
                 // CLI 자체 SqlModel에도 주입 (혹시 직접 참조하는 경우 대비)
                 const SqlModel = (await import('../lib/database/SqlModel.js')).default;
                 SqlModel.setConnectionManager(cm);
+
+                // 프로젝트의 node_modules/@fuzionx/framework 가 별도 복사본(non-symlink)일 수 있으므로
+                // 프로젝트 경로의 SqlModel/PostgreModel 에도 직접 주입
+                try {
+                    const projFwPath = path.resolve('node_modules/@fuzionx/framework/lib/database');
+                    const projSqlModel = (await import(pathToFileURL(path.join(projFwPath, 'SqlModel.js')).href)).default;
+                    if (projSqlModel && typeof projSqlModel.setConnectionManager === 'function') {
+                        projSqlModel.setConnectionManager(cm);
+                    }
+                } catch {}
+
             }
 
             // 시드 실행
@@ -990,5 +1198,7 @@ export async function run(args) {
   fx config                         Print fuzionx.yaml
   fx db:sync                        Sync models → DB (--apply)
   fx db:seed                        Run seed files (database/seeds)
+  fx db:fresh --confirm              Drop all tables → sync → seed
+  fx db:reset --confirm              Alias for db:fresh
 `);
 }

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

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

package/lib/core/Application.js

@@ -978,6 +978,11 @@ export default class Application {
                     inst.onDisconnect(socket);
                 });
 
+                // 원격 메타데이터 변경 이벤트 (Hub METADATA_UPDATE → onRemoteMetadataUpdate)
+                wsNs.on('metadata_update', (socket, key, value) => {
+                    inst.onRemoteMetadataUpdate(socket, key, value);
+                });
+
                 this.logger.info(`[WS] 핸들러 등록: ${namespace} (events: ${[...eventMap.keys()].join(', ')})`);
             }
         }

package/lib/realtime/WsHandler.js

@@ -104,4 +104,16 @@ export default class WsHandler extends Base {
     async onError(socket, error) {
         this.logger?.error(`WS error in ${this.constructor.namespace}:`, error);
     }
+
+    /**
+     * 원격 세션 메타데이터 변경 시 (서브클래스에서 오버라이드)
+     *
+     * Hub METADATA_UPDATE → 다른 워커에서 setMetadata 호출 시 발생.
+     * 접속자 관리 등 cross-worker 상태 동기화에 사용.
+     *
+     * @param {object} socket - 원격 세션 소켓 래퍼 (send → Hub DIRECT)
+     * @param {string} key - 변경된 메타데이터 키
+     * @param {string} value - 변경된 메타데이터 값
+     */
+    async onRemoteMetadataUpdate(socket, key, value) {}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzionx/framework",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "type": "module",
   "description": "Full-stack MVC framework built on @fuzionx/core — Controller, Service, Model, Middleware, DI, EventBus",
   "main": "index.js",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1028.0",
-    "@fuzionx/core": "^0.1.73",
+    "@fuzionx/core": "^0.1.75",
     "better-sqlite3": "^12.8.0",
     "knex": "^3.2.5",
     "mongoose": "^9.3.2",