sonamu 0.6.0 → 0.7.1

package/dist/api/validator.js

@@ -0,0 +1,81 @@
+export const RESERVED_KEYWORDS = new Set([
+    "abstract",
+    "arguments",
+    "async",
+    "await",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "function",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "int",
+    "interface",
+    "let",
+    "long",
+    "native",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "short",
+    "static",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "transient",
+    "true",
+    "try",
+    "typeof",
+    "using",
+    "var",
+    "void",
+    "volatile",
+    "while",
+    "with",
+    "yield"
+]);
+export class ApiValidationError extends Error {
+    constructor(message){
+        super(`[Sonamu API Validation] ${message}`);
+        this.name = "ApiValidationError";
+    }
+}
+export function validateMethodName(methodName) {
+    if (RESERVED_KEYWORDS.has(methodName)) {
+        throw new ApiValidationError(`Method name ${methodName} is a reserved keyword. Please choose a different name.`);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/bin/build-config.d.ts

@@ -1,3 +1,7 @@
+/**
+ * 소스 코드가 담길 디렉토리 경로
+ */
+export declare const SRC_DIR = "src";
 /**
  * 빌드 결과물이 담길 디렉토리 경로
  */
@@ -6,7 +10,7 @@ export declare const BUILD_DIR = "dist";
  * SWC 빌드 명령어
  * .swcrc 설정 사용
  */
-export declare const SWC_BUILD_COMMAND = "swc src -d dist --strip-leading-paths";
+export declare const SWC_BUILD_COMMAND: (configFilePath: string) => string;
 /**
  * TSC 타입 체크 명령어
  */

package/dist/bin/build-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-config.d.ts","sourceRoot":"","sources":["../../src/bin/build-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,SAAS,SAAS,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,0CAAkD,CAAC;AAEjF;;GAEG;AACH,eAAO,MAAM,sBAAsB,iBAAiB,CAAC"}
+{"version":3,"file":"build-config.d.ts","sourceRoot":"","sources":["../../src/bin/build-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,QAAQ,CAAC;AAE7B;;GAEG;AACH,eAAO,MAAM,SAAS,SAAS,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,MAAM,WACiC,CAAC;AAE1F;;GAEG;AACH,eAAO,MAAM,sBAAsB,iBAAiB,CAAC"}

package/dist/bin/build-config.js

@@ -1,12 +1,15 @@
+/**
+ * 소스 코드가 담길 디렉토리 경로
+ */ export const SRC_DIR = "src";
 /**
  * 빌드 결과물이 담길 디렉토리 경로
  */ export const BUILD_DIR = "dist";
 /**
  * SWC 빌드 명령어
  * .swcrc 설정 사용
- */ export const SWC_BUILD_COMMAND = `swc src -d ${BUILD_DIR} --strip-leading-paths`;
+ */ export const SWC_BUILD_COMMAND = (configFilePath)=>`swc ${SRC_DIR} -d ${BUILD_DIR} --config-file ${configFilePath}  --strip-leading-paths`;
 /**
  * TSC 타입 체크 명령어
  */ export const TSC_TYPE_CHECK_COMMAND = `tsc --noEmit`;
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vYnVpbGQtY29uZmlnLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog67mM65OcIOqysOqzvOusvOydtCDri7TquLgg65SU66CJ7Yag66asIOqyveuhnFxuICovXG5leHBvcnQgY29uc3QgQlVJTERfRElSID0gXCJkaXN0XCI7XG5cbi8qKlxuICogU1dDIOu5jOuTnCDrqoXroLnslrRcbiAqIC5zd2NyYyDshKTsoJUg7IKs7JqpXG4gKi9cbmV4cG9ydCBjb25zdCBTV0NfQlVJTERfQ09NTUFORCA9IGBzd2Mgc3JjIC1kICR7QlVJTERfRElSfSAtLXN0cmlwLWxlYWRpbmctcGF0aHNgO1xuXG4vKipcbiAqIFRTQyDtg4DsnoUg7LK07YGsIOuqheugueyWtFxuICovXG5leHBvcnQgY29uc3QgVFNDX1RZUEVfQ0hFQ0tfQ09NTUFORCA9IGB0c2MgLS1ub0VtaXRgO1xuIl0sIm5hbWVzIjpbIkJVSUxEX0RJUiIsIlNXQ19CVUlMRF9DT01NQU5EIiwiVFNDX1RZUEVfQ0hFQ0tfQ09NTUFORCJdLCJtYXBwaW5ncyI6IkFBQUE7O0NBRUMsR0FDRCxPQUFPLE1BQU1BLFlBQVksT0FBTztBQUVoQzs7O0NBR0MsR0FDRCxPQUFPLE1BQU1DLG9CQUFvQixDQUFDLFdBQVcsRUFBRUQsVUFBVSxzQkFBc0IsQ0FBQyxDQUFDO0FBRWpGOztDQUVDLEdBQ0QsT0FBTyxNQUFNRSx5QkFBeUIsQ0FBQyxZQUFZLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vYnVpbGQtY29uZmlnLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog7IaM7IqkIOy9lOuTnOqwgCDri7TquLgg65SU66CJ7Yag66asIOqyveuhnFxuICovXG5leHBvcnQgY29uc3QgU1JDX0RJUiA9IFwic3JjXCI7XG5cbi8qKlxuICog67mM65OcIOqysOqzvOusvOydtCDri7TquLgg65SU66CJ7Yag66asIOqyveuhnFxuICovXG5leHBvcnQgY29uc3QgQlVJTERfRElSID0gXCJkaXN0XCI7XG5cbi8qKlxuICogU1dDIOu5jOuTnCDrqoXroLnslrRcbiAqIC5zd2NyYyDshKTsoJUg7IKs7JqpXG4gKi9cbmV4cG9ydCBjb25zdCBTV0NfQlVJTERfQ09NTUFORCA9IChjb25maWdGaWxlUGF0aDogc3RyaW5nKSA9PlxuICBgc3djICR7U1JDX0RJUn0gLWQgJHtCVUlMRF9ESVJ9IC0tY29uZmlnLWZpbGUgJHtjb25maWdGaWxlUGF0aH0gIC0tc3RyaXAtbGVhZGluZy1wYXRoc2A7XG5cbi8qKlxuICogVFNDIO2DgOyehSDssrTtgawg66qF66C57Ja0XG4gKi9cbmV4cG9ydCBjb25zdCBUU0NfVFlQRV9DSEVDS19DT01NQU5EID0gYHRzYyAtLW5vRW1pdGA7XG4iXSwibmFtZXMiOlsiU1JDX0RJUiIsIkJVSUxEX0RJUiIsIlNXQ19CVUlMRF9DT01NQU5EIiwiY29uZmlnRmlsZVBhdGgiLCJUU0NfVFlQRV9DSEVDS19DT01NQU5EIl0sIm1hcHBpbmdzIjoiQUFBQTs7Q0FFQyxHQUNELE9BQU8sTUFBTUEsVUFBVSxNQUFNO0FBRTdCOztDQUVDLEdBQ0QsT0FBTyxNQUFNQyxZQUFZLE9BQU87QUFFaEM7OztDQUdDLEdBQ0QsT0FBTyxNQUFNQyxvQkFBb0IsQ0FBQ0MsaUJBQ2hDLENBQUMsSUFBSSxFQUFFSCxRQUFRLElBQUksRUFBRUMsVUFBVSxlQUFlLEVBQUVFLGVBQWUsdUJBQXVCLENBQUMsQ0FBQztBQUUxRjs7Q0FFQyxHQUNELE9BQU8sTUFBTUMseUJBQXlCLENBQUMsWUFBWSxDQUFDLENBQUMifQ==

package/dist/bin/cli.js

@@ -1,23 +1,28 @@
 import chalk from "chalk";
 import dotenv from "dotenv";
 dotenv.config();
-import path from "path";
-import { fileURLToPath } from "url";
-import { tsicli } from "tsicli";
 import { execSync, spawn } from "child_process";
-import { mkdir, readdir, writeFile } from "node:fs/promises";
-import { exists } from "../utils/fs-utils.js";
+import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import knex from "knex";
+import { createRequire } from "module";
+import path from "path";
 import process from "process";
+import { tsicli } from "tsicli";
 import { Sonamu } from "../api/index.js";
-import knex from "knex";
 import { EntityManager } from "../entity/entity-manager.js";
 import { Migrator } from "../migration/migrator.js";
 import { FixtureManager } from "../testing/fixture-manager.js";
+import { exists } from "../utils/fs-utils.js";
 import { findApiRootPath } from "../utils/utils.js";
+import { BUILD_DIR, SWC_BUILD_COMMAND, TSC_TYPE_CHECK_COMMAND } from "./build-config.js";
 let migrator;
 async function bootstrap() {
-    // dev 명령어가 아닌 경우에만 Sonamu 초기화
-    if (process.argv[2] !== "dev") {
+    const notToInit = [
+        "dev",
+        "build",
+        "start"
+    ].includes(process.argv[2] ?? "");
+    if (!notToInit) {
         await Sonamu.init(false, false);
     }
     await tsicli(process.argv, {
@@ -106,20 +111,22 @@ async function bootstrap() {
             [
                 "ui"
             ],
+            [
+                "sync"
+            ],
             [
                 "dev"
             ],
+            [
+                "build"
+            ],
             [
                 "start"
             ]
         ],
         runners: {
-            migrate_run,
-            migrate_check,
-            migrate_rollback,
-            migrate_clear,
-            migrate_reset,
             migrate_status,
+            migrate_run,
             fixture_init,
             fixture_import,
             fixture_sync,
@@ -130,26 +137,52 @@ async function bootstrap() {
             ui,
             // scaffold_view_list,
             // scaffold_view_form,
+            sync,
             dev,
+            build,
             start
         }
     });
 }
 bootstrap().finally(async ()=>{
-    if (migrator) {
-        await migrator.destroy();
-    }
     await FixtureManager.destroy();
 });
-async function dev() {
+/**
+ * pnpm sync 하면 실행되는 함수입니다.
+ * 프로젝트를 싱크합니다.
+ */ async function sync() {
+    await Sonamu.syncer.sync();
+}
+/**
+ * pnpm dev 하면 실행되는 함수입니다.
+ * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
+ *
+ * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/loader를,
+ * HMR을 지원하기 위해 @sonamu-kit/hot-hook을 import하며,
+ * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.
+ *
+ * 이때 @sonamu-kit/loader와 @sonamu-kit/hot-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
+ * 또한 실행에 사용하는 @sonamu-kit/hot-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
+ * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ async function dev() {
     const apiRoot = findApiRootPath();
-    const entryPoint = 'src/index.ts';
-    console.log(chalk.yellow.bold('🚀 Starting Sonamu dev server...\n'));
-    const serverProcess = spawn("hot-runner", [
+    const entryPoint = "src/index.ts";
+    console.log(chalk.yellow.bold("🚀 Starting Sonamu dev server...\n"));
+    // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hot-runner의 bin/run.js를 사용합니다.
+    // 이 경로(/bin/run.js)는 @sonamu-kit/hot-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.
+    const hotRunnerBinPath = createRequire(import.meta.url).resolve("@sonamu-kit/hot-runner/bin/run.js");
+    const serverProcess = spawn(process.execPath, [
+        hotRunnerBinPath,
         "--clear-screen=false",
-        "--node-args=--import=@sonamu-kit/loader",
+        "--node-args=--import=sonamu/loader-register",
         "--node-args=--import=sonamu/hot-hook-register",
         "--node-args=--enable-source-maps",
+        "--on-key=r:restart:Restart server",
+        `--on-key=f:shell(rm ${path.join(apiRoot, "sonamu.lock")}):restart:Force restart`,
+        "--on-key=enter:shell(echo hi):Key binding test",
+        "--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart",
         entryPoint
     ], {
         cwd: apiRoot,
@@ -163,34 +196,121 @@ async function dev() {
     });
     // 종료 처리
     const cleanup = ()=>{
-        console.log(chalk.yellow('\n\n👋 Shutting down...'));
-        serverProcess.kill('SIGTERM');
+        console.log(chalk.yellow("\n\n👋 Shutting down..."));
+        serverProcess.kill("SIGTERM");
         process.exit(0);
     };
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-    serverProcess.on('exit', (code)=>{
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    serverProcess.on("exit", (code)=>{
         if (code !== 0) {
             console.error(chalk.red(`❌ Server exited with code ${code}`));
             process.exit(code || 1);
         }
     });
 }
-async function start() {
-    const entryPoint = 'dist/index.js';
+/**
+ * pnpm build 하면 실행되는 함수입니다.
+ * 프로젝트를 빌드합니다.
+ *
+ * 빌드에 필요한 .swcrc는 프로젝트 루트에서 찾고, 없으면 sonamu가 관리하는 .swcrc.project-default를 사용합니다.
+ * sonamu.config.ts는 src에 들어있지 않기 때문에 SWC_BUILD_COMMAND로 빌드되지 않습니다.
+ * 따라서 따로 빌드해줍니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ async function build() {
+    const apiRoot = findApiRootPath();
+    // 출력 디렉토리를 제거합니다.
+    try {
+        console.log(chalk.blue("Removing build directory..."));
+        if (await exists(BUILD_DIR)) {
+            await rm(BUILD_DIR, {
+                recursive: true,
+                force: true
+            });
+        }
+    } catch (error) {
+        console.error(chalk.red("Remove build directory failed."), error);
+        process.exit(1);
+    }
+    // .swcrc 파일을 지정합니다.
+    let swcFilePath = ".swcrc";
+    try {
+        if (await exists(swcFilePath)) {
+            // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.
+            console.log(chalk.blue("Using .swcrc from project root..."));
+        } else {
+            // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.
+            console.log(chalk.blue("Using default .swcrc from sonamu package..."));
+            swcFilePath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
+        }
+    } catch (error) {
+        console.error(chalk.red("Setting up swc config file failed."), error);
+        process.exit(1);
+    }
+    // 소스 디렉토리를 빌드합니다.
+    try {
+        console.log(chalk.blue("Building with swc..."));
+        execSync(SWC_BUILD_COMMAND(swcFilePath), {
+            cwd: apiRoot,
+            stdio: "inherit"
+        });
+    } catch (error) {
+        console.error(chalk.red("Build failed."), error);
+        process.exit(1);
+    }
+    // sonamu.config.ts만 따로 빌드합니다.
+    // 이 친구는 src에 들어있지 않기 때문에 SWC_BUILD_COMMAND로 빌드되지 않습니다.
+    // 따라서 따로 빌드해줍니다.
+    try {
+        const configPath = path.join(apiRoot, "sonamu.config.ts");
+        if (await exists(configPath)) {
+            console.log(chalk.blue("Building sonamu.config.ts..."));
+            execSync(`swc ${configPath} -o ${BUILD_DIR}/sonamu.config.js`, {
+                cwd: apiRoot,
+                stdio: "inherit"
+            });
+        }
+    } catch (error) {
+        console.error(chalk.red("Building sonamu.config.ts failed."), error);
+        process.exit(1);
+    }
+    // 마지막에는 타입 체크를 해요.
+    try {
+        console.log(chalk.blue("Checking types with tsc..."));
+        execSync(TSC_TYPE_CHECK_COMMAND, {
+            cwd: apiRoot,
+            stdio: "inherit"
+        });
+    } catch (error) {
+        console.error(chalk.red("Type check failed."), error);
+        process.exit(1);
+    }
+}
+/**
+ * pnpm start 하면 실행되는 함수입니다.
+ * 빌드된 프로젝트를 실행합니다.
+ *
+ * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.
+ * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ async function start() {
+    const apiRoot = findApiRootPath();
+    const entryPoint = "dist/index.js";
     if (!await exists(entryPoint)) {
         console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));
         console.log(chalk.blue("Run: yarn sonamu build"));
         return;
     }
     const { spawn } = await import("child_process");
-    const serverProcess = spawn("node", [
+    const serverProcess = spawn(process.execPath, [
         "--enable-source-maps",
         "-r",
         "dotenv/config",
         entryPoint
     ], {
-        cwd: Sonamu.apiRootPath,
+        cwd: apiRoot,
         stdio: "inherit"
     });
     process.on("SIGINT", ()=>{
@@ -200,20 +320,14 @@ async function start() {
 }
 async function setupMigrator() {
     // migrator
-    migrator = new Migrator({
-        mode: "dev"
-    });
+    migrator = new Migrator();
 }
 async function setupFixtureManager() {
     FixtureManager.init();
 }
 async function migrate_run() {
     await setupMigrator();
-    await migrator.run();
-}
-async function migrate_check() {
-    await setupMigrator();
-    await migrator.check();
+    await migrator.runAction("apply", Object.keys(Sonamu.dbConfig));
 }
 async function migrate_status() {
     await setupMigrator();
@@ -221,18 +335,6 @@ async function migrate_status() {
     // status;
     console.log(status);
 }
-async function migrate_rollback() {
-    await setupMigrator();
-    await migrator.rollback();
-}
-async function migrate_clear() {
-    await setupMigrator();
-    await migrator.clearPendingList();
-}
-async function migrate_reset() {
-    await setupMigrator();
-    await migrator.resetAll();
-}
 async function fixture_init() {
     const srcConfig = Sonamu.dbConfig.development_master;
     const targets = [
@@ -241,17 +343,13 @@ async function fixture_init() {
             config: Sonamu.dbConfig.fixture_remote
         },
         {
-            label: "(LOCAL) Fixture DB",
-            config: Sonamu.dbConfig.fixture_local,
+            label: "(LOCAL) Testing DB",
+            config: Sonamu.dbConfig.test,
             toSkip: (()=>{
                 const remoteConn = Sonamu.dbConfig.fixture_remote.connection;
-                const localConn = Sonamu.dbConfig.fixture_local.connection;
+                const localConn = Sonamu.dbConfig.test.connection;
                 return remoteConn.host === localConn.host && remoteConn.database === localConn.database;
             })()
-        },
-        {
-            label: "(LOCAL) Testing DB",
-            config: Sonamu.dbConfig.test
         }
     ];
     // 1. 기준DB 스키마를 덤프
@@ -318,7 +416,7 @@ async function stub_practice(name) {
             });
         }
         const filteredSeqs = fileNames.filter((fileName)=>fileName.startsWith("p") && fileName.endsWith(".ts")).map((fileName)=>{
-            const [, seqNo] = fileName.match(/^p([0-9]+)\-/) ?? [
+            const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [
                 "0",
                 "0"
             ];
@@ -351,7 +449,8 @@ async function stub_practice(name) {
 }
 async function stub_entity(entityId) {
     await Sonamu.syncer.createEntity({
-        entityId
+        entityId,
+        title: entityId
     });
 }
 async function scaffold_model(entityId) {
@@ -366,9 +465,11 @@ async function scaffold_model_test(entityId) {
 }
 async function ui() {
     try {
-        // @sonamu-kit/ui의 run-ui.ts 스크립트 경로 찾기
-        const uiModulePath = await import.meta.resolve("@sonamu-kit/ui");
-        const uiNodePath = path.join(path.dirname(fileURLToPath(uiModulePath)), "run-ui.js");
+        // 사용자 프로젝트의 패키지들 중에서 @sonamu-kit/ui를 찾습니다.
+        // 이를 위해서 createRequire를 사용하여 프로젝트 경로 기준으로 resolve합니다.
+        const projectRequire = createRequire(path.join(Sonamu.apiRootPath, "package.json"));
+        const uiPackagePath = projectRequire.resolve("@sonamu-kit/ui"); // 없으면 여기서 터져요(MODULE_NOT_FOUND)
+        const uiNodePath = path.join(path.dirname(uiPackagePath), "run-ui.js");
         if (!await exists(uiNodePath)) {
             console.log(chalk.red(`UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`));
             return;
@@ -376,7 +477,7 @@ async function ui() {
         // UI를 별도 프로세스로 실행 (hot-hook 활성화)
         const uiProcess = spawn(process.execPath, [
             "--import",
-            "@sonamu-kit/loader",
+            "sonamu/loader-register",
             "--import",
             "sonamu/hot-hook-register",
             "--enable-source-maps",
@@ -415,4 +516,4 @@ async function ui() {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bin/cli.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dotenv from \"dotenv\";\ndotenv.config();\n\nimport path from \"path\";\nimport { fileURLToPath } from \"url\";\nimport { tsicli } from \"tsicli\";\nimport { execSync, spawn } from \"child_process\";\nimport { mkdir, readdir, writeFile } from \"fs/promises\";\nimport { exists } from \"../utils/fs-utils\";\nimport process from \"process\";\nimport { Sonamu } from \"../api\";\nimport knex, { Knex } from \"knex\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Migrator } from \"../migration/migrator\";\nimport { FixtureManager } from \"../testing/fixture-manager\";\nimport { findApiRootPath } from \"../utils/utils\";\n\nlet migrator: Migrator;\n\nasync function bootstrap() {\n  // dev 명령어가 아닌 경우에만 Sonamu 초기화\n  if (process.argv[2] !== \"dev\") {\n    await Sonamu.init(false, false);\n  }\n\n  await tsicli(process.argv, {\n    types: {\n      \"#entityId\": {\n        type: \"autocomplete\",\n        name: \"#entityId\",\n        message: \"Please input #entityId\",\n        choices: EntityManager.getAllParentIds().map((entityId) => ({\n          title: entityId,\n          value: entityId,\n        })),\n      },\n      \"#recordIds\": \"number[]\",\n      \"#name\": \"string\",\n    },\n    args: [\n      [\"fixture\", \"init\"],\n      [\"fixture\", \"import\", \"#entityId\", \"#recordIds\"],\n      [\"fixture\", \"sync\"],\n      [\"migrate\", \"run\"],\n      [\"migrate\", \"check\"],\n      [\"migrate\", \"rollback\"],\n      [\"migrate\", \"reset\"],\n      [\"migrate\", \"clear\"],\n      [\"migrate\", \"status\"],\n      [\"stub\", \"practice\", \"#name\"],\n      [\"stub\", \"entity\", \"#name\"],\n      [\"scaffold\", \"model\", \"#entityId\"],\n      [\"scaffold\", \"model_test\", \"#entityId\"],\n      [\"scaffold\", \"view_list\", \"#entityId\"],\n      [\"scaffold\", \"view_form\", \"#entityId\"],\n      [\"ui\"],\n      [\"dev\"],\n      [\"start\"],\n    ],\n    runners: {\n      migrate_run,\n      migrate_check,\n      migrate_rollback,\n      migrate_clear,\n      migrate_reset,\n      migrate_status,\n      fixture_init,\n      fixture_import,\n      fixture_sync,\n      stub_practice,\n      stub_entity,\n      scaffold_model,\n      scaffold_model_test,\n      ui,\n      // scaffold_view_list,\n      // scaffold_view_form,\n      dev,\n      start,\n    },\n  });\n}\nbootstrap().finally(async () => {\n  if (migrator) {\n    await migrator.destroy();\n  }\n  await FixtureManager.destroy();\n});\n\nasync function dev() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = 'src/index.ts';   \n\n  console.log(chalk.yellow.bold('🚀 Starting Sonamu dev server...\\n'));\n\n  const serverProcess = spawn(\n    \"hot-runner\",\n    [\n      \"--clear-screen=false\",\n      \"--node-args=--import=@sonamu-kit/loader\",\n      \"--node-args=--import=sonamu/hot-hook-register\",\n      \"--node-args=--enable-source-maps\",\n      entryPoint,\n    ],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n      env: {\n        ...process.env,\n        NODE_ENV: \"development\",\n        HOT: \"yes\",\n        API_ROOT_PATH: apiRoot,\n      },\n    }\n  );\n\n  // 종료 처리\n  const cleanup = () => {\n    console.log(chalk.yellow('\\n\\n👋 Shutting down...'));\n    serverProcess.kill('SIGTERM');\n    process.exit(0);\n  };\n\n  process.on('SIGINT', cleanup);\n  process.on('SIGTERM', cleanup);\n\n  serverProcess.on('exit', (code) => {\n    if (code !== 0) {\n      console.error(chalk.red(`❌ Server exited with code ${code}`));\n      process.exit(code || 1);\n    }\n  });\n}\n\nasync function start() {\n  const entryPoint = 'dist/index.js';  \n\n  if (!(await exists(entryPoint))) {\n    console.log(\n      chalk.red(`${entryPoint} not found. Please build your project first.`)\n    );\n    console.log(chalk.blue(\"Run: yarn sonamu build\"));\n    return;\n  }\n\n  const { spawn } = await import(\"child_process\");\n  const serverProcess = spawn(\n    \"node\",\n    [\"--enable-source-maps\", \"-r\", \"dotenv/config\", entryPoint],\n    {\n      cwd: Sonamu.apiRootPath,\n      stdio: \"inherit\",\n    }\n  );\n\n  process.on(\"SIGINT\", () => {\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  });\n}\n\nasync function setupMigrator() {\n  // migrator\n  migrator = new Migrator({\n    mode: \"dev\",\n  });\n}\n\nasync function setupFixtureManager() {\n  FixtureManager.init();\n}\n\nasync function migrate_run() {\n  await setupMigrator();\n\n  await migrator.run();\n}\n\nasync function migrate_check() {\n  await setupMigrator();\n\n  await migrator.check();\n}\n\nasync function migrate_status() {\n  await setupMigrator();\n\n  const status = await migrator.getStatus();\n  // status;\n  console.log(status);\n}\n\nasync function migrate_rollback() {\n  await setupMigrator();\n\n  await migrator.rollback();\n}\n\nasync function migrate_clear() {\n  await setupMigrator();\n\n  await migrator.clearPendingList();\n}\n\nasync function migrate_reset() {\n  await setupMigrator();\n\n  await migrator.resetAll();\n}\n\nasync function fixture_init() {\n  const srcConfig = Sonamu.dbConfig.development_master;\n  const targets = [\n    {\n      label: \"(REMOTE) Fixture DB\",\n      config: Sonamu.dbConfig.fixture_remote,\n    },\n    {\n      label: \"(LOCAL) Fixture DB\",\n      config: Sonamu.dbConfig.fixture_local,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture_remote\n          .connection as Knex.ConnectionConfig;\n        const localConn = Sonamu.dbConfig.fixture_local\n          .connection as Knex.ConnectionConfig;\n        return (\n          remoteConn.host === localConn.host &&\n          remoteConn.database === localConn.database\n        );\n      })(),\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n    },\n  ] as {\n    label: string;\n    config: Knex.Config;\n    toSkip?: boolean;\n  }[];\n\n  // 1. 기준DB 스키마를 덤프\n  console.log(\"DUMP...\");\n  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;\n  const srcConn = srcConfig.connection as Knex.ConnectionConfig;\n  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;\n  execSync(\n    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`\n  );\n  const _db = knex(srcConfig);\n  const [[migrations]] = await _db.raw(\n    \"SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'\",\n    [srcConn.database]\n  );\n  if (migrations.count > 0) {\n    execSync(\n      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`\n    );\n  }\n\n  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기\n  for await (const { label, config, toSkip } of targets) {\n    const conn = config.connection as Knex.ConnectionConfig;\n\n    if (toSkip === true) {\n      console.log(chalk.red(`${label}: Skipped!`));\n      continue;\n    }\n\n    const db = knex({\n      ...config,\n      connection: {\n        ...((config.connection ?? {}) as Knex.ConnectionConfig),\n        database: undefined,\n      },\n    });\n    const [[row]] = await db.raw(`SHOW DATABASES LIKE \"${conn.database}\"`);\n    if (row) {\n      console.log(\n        chalk.yellow(`${label}: Database \"${conn.database}\" Already exists`)\n      );\n      await db.destroy();\n      continue;\n    }\n\n    console.log(`SYNC to ${label}...`);\n    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;\n    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} -e 'CREATE DATABASE \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);\n    if (await exists(migrationsDump)) {\n      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);\n    }\n\n    await db.destroy();\n  }\n\n  await _db.destroy();\n}\n\nasync function fixture_import(entityId: string, recordIds: number[]) {\n  await setupFixtureManager();\n\n  await FixtureManager.importFixture(entityId, recordIds);\n  await FixtureManager.sync();\n}\n\nasync function fixture_sync() {\n  await setupFixtureManager();\n\n  await FixtureManager.sync();\n}\n\nasync function stub_practice(name: string) {\n  const practiceDir = path.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  const fileNames = await readdir(practiceDir);\n\n  const maxSeqNo = await (async () => {\n    if (!(await exists(practiceDir))) {\n      await mkdir(practiceDir, { recursive: true });\n    }\n\n    const filteredSeqs = fileNames\n      .filter(\n        (fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\")\n      )\n      .map((fileName) => {\n        const [, seqNo] = fileName.match(/^p([0-9]+)\\-/) ?? [\"0\", \"0\"];\n        return parseInt(seqNo);\n      })\n      .sort((a, b) => b - a);\n\n    if (filteredSeqs.length > 0) {\n      return filteredSeqs[0];\n    }\n\n    return 0;\n  })();\n\n  const currentSeqNo = maxSeqNo + 1;\n  const fileName = `p${currentSeqNo}-${name}.ts`;\n  const dstPath = path.join(practiceDir, fileName);\n\n  const code = [\n    `import { Sonamu } from \"sonamu\";`,\n    \"\",\n    `console.clear();`,\n    `console.log(\"${fileName}\");`,\n    \"\",\n    `Sonamu.runScript(async () => {`,\n    ` // TODO`,\n    `});`,\n    \"\",\n  ].join(\"\\n\");\n  await writeFile(dstPath, code);\n\n  execSync(`code ${dstPath}`);\n\n  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(\n    \".ts\",\n    \".js\"\n  )}`;\n  console.log(`${chalk.blue(runCode)} copied to clipboard.`);\n  execSync(`echo \"${runCode}\" | pbcopy`);\n}\n\nasync function stub_entity(entityId: string) {\n  await Sonamu.syncer.createEntity({ entityId });\n}\n\nasync function scaffold_model(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model\", {\n    entityId,\n  });\n}\n\nasync function scaffold_model_test(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model_test\", {\n    entityId,\n  });\n}\n\nasync function ui() {\n  try {\n    // @sonamu-kit/ui의 run-ui.ts 스크립트 경로 찾기\n    const uiModulePath = await import.meta.resolve(\"@sonamu-kit/ui\");\n    const uiNodePath = path.join(\n      path.dirname(fileURLToPath(uiModulePath)),\n      \"run-ui.js\"\n    );\n\n    if (!(await exists(uiNodePath))) {\n      console.log(\n        chalk.red(\n          `UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`\n        )\n      );\n      return;\n    }\n\n    // UI를 별도 프로세스로 실행 (hot-hook 활성화)\n    const uiProcess = spawn(\n      process.execPath,\n      [\n        \"--import\", \"@sonamu-kit/loader\",\n        \"--import\", \"sonamu/hot-hook-register\",\n        \"--enable-source-maps\",\n        \"--no-warnings\",\n        uiNodePath,\n      ],\n      {\n        stdio: \"inherit\",\n        env: {\n          ...process.env,\n          HOT: \"yes\",\n          PROJECT_NAME:\n            Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),\n          API_ROOT_PATH: Sonamu.apiRootPath,\n          UI_PORT: (Sonamu.config.ui?.port ?? 57000).toString(),\n        },\n      }\n    );\n\n    // 종료 처리\n    const cleanup = () => {\n      console.log(chalk.yellow(\"\\n\\n👋 Shutting down UI server...\"));\n      uiProcess.kill(\"SIGTERM\");\n      process.exit(0);\n    };\n\n    process.on(\"SIGINT\", cleanup);\n    process.on(\"SIGTERM\", cleanup);\n\n    uiProcess.on(\"exit\", (code) => {\n      if (code !== 0) {\n        console.error(chalk.red(`❌ UI server exited with code ${code}`));\n        process.exit(code || 1);\n      }\n    });\n  } catch (e: unknown) {\n    if (e instanceof Error && e.message.includes(\"isn't declared\")) {\n      console.log(\n        `You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`\n      );\n      return;\n    }\n    throw e;\n  }\n}\n"],"names":["chalk","dotenv","config","path","fileURLToPath","tsicli","execSync","spawn","mkdir","readdir","writeFile","exists","process","Sonamu","knex","EntityManager","Migrator","FixtureManager","findApiRootPath","migrator","bootstrap","argv","init","types","type","name","message","choices","getAllParentIds","map","entityId","title","value","args","runners","migrate_run","migrate_check","migrate_rollback","migrate_clear","migrate_reset","migrate_status","fixture_init","fixture_import","fixture_sync","stub_practice","stub_entity","scaffold_model","scaffold_model_test","ui","dev","start","finally","destroy","apiRoot","entryPoint","console","log","yellow","bold","serverProcess","cwd","stdio","env","NODE_ENV","HOT","API_ROOT_PATH","cleanup","kill","exit","on","code","error","red","blue","apiRootPath","setupMigrator","mode","setupFixtureManager","run","check","status","getStatus","rollback","clearPendingList","resetAll","srcConfig","dbConfig","development_master","targets","label","fixture_remote","fixture_local","toSkip","remoteConn","connection","localConn","host","database","test","dumpFilename","Date","now","srcConn","migrationsDump","user","password","_db","migrations","raw","count","conn","db","undefined","row","mysqlCmd","recordIds","importFixture","sync","practiceDir","join","fileNames","maxSeqNo","recursive","filteredSeqs","filter","fileName","startsWith","endsWith","seqNo","match","parseInt","sort","a","b","length","currentSeqNo","dstPath","runCode","replace","syncer","createEntity","generateTemplate","uiModulePath","resolve","uiNodePath","dirname","uiProcess","execPath","PROJECT_NAME","projectName","basename","UI_PORT","port","toString","e","Error","includes"],"mappings":"AAAA,OAAOA,WAAW,QAAQ;AAC1B,OAAOC,YAAY,SAAS;AAC5BA,OAAOC,MAAM;AAEb,OAAOC,UAAU,OAAO;AACxB,SAASC,aAAa,QAAQ,MAAM;AACpC,SAASC,MAAM,QAAQ,SAAS;AAChC,SAASC,QAAQ,EAAEC,KAAK,QAAQ,gBAAgB;AAChD,SAASC,KAAK,EAAEC,OAAO,EAAEC,SAAS,QAAQ,mBAAc;AACxD,SAASC,MAAM,QAAQ,uBAAoB;AAC3C,OAAOC,aAAa,UAAU;AAC9B,SAASC,MAAM,QAAQ,kBAAS;AAChC,OAAOC,UAAoB,OAAO;AAClC,SAASC,aAAa,QAAQ,8BAA2B;AACzD,SAASC,QAAQ,QAAQ,2BAAwB;AACjD,SAASC,cAAc,QAAQ,gCAA6B;AAC5D,SAASC,eAAe,QAAQ,oBAAiB;AAEjD,IAAIC;AAEJ,eAAeC;IACb,8BAA8B;IAC9B,IAAIR,QAAQS,IAAI,CAAC,EAAE,KAAK,OAAO;QAC7B,MAAMR,OAAOS,IAAI,CAAC,OAAO;IAC3B;IAEA,MAAMjB,OAAOO,QAAQS,IAAI,EAAE;QACzBE,OAAO;YACL,aAAa;gBACXC,MAAM;gBACNC,MAAM;gBACNC,SAAS;gBACTC,SAASZ,cAAca,eAAe,GAAGC,GAAG,CAAC,CAACC,WAAc,CAAA;wBAC1DC,OAAOD;wBACPE,OAAOF;oBACT,CAAA;YACF;YACA,cAAc;YACd,SAAS;QACX;QACAG,MAAM;YACJ;gBAAC;gBAAW;aAAO;YACnB;gBAAC;gBAAW;gBAAU;gBAAa;aAAa;YAChD;gBAAC;gBAAW;aAAO;YACnB;gBAAC;gBAAW;aAAM;YAClB;gBAAC;gBAAW;aAAQ;YACpB;gBAAC;gBAAW;aAAW;YACvB;gBAAC;gBAAW;aAAQ;YACpB;gBAAC;gBAAW;aAAQ;YACpB;gBAAC;gBAAW;aAAS;YACrB;gBAAC;gBAAQ;gBAAY;aAAQ;YAC7B;gBAAC;gBAAQ;gBAAU;aAAQ;YAC3B;gBAAC;gBAAY;gBAAS;aAAY;YAClC;gBAAC;gBAAY;gBAAc;aAAY;YACvC;gBAAC;gBAAY;gBAAa;aAAY;YACtC;gBAAC;gBAAY;gBAAa;aAAY;YACtC;gBAAC;aAAK;YACN;gBAAC;aAAM;YACP;gBAAC;aAAQ;SACV;QACDC,SAAS;YACPC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACA,sBAAsB;YACtB,sBAAsB;YACtBC;YACAC;QACF;IACF;AACF;AACA9B,YAAY+B,OAAO,CAAC;IAClB,IAAIhC,UAAU;QACZ,MAAMA,SAASiC,OAAO;IACxB;IACA,MAAMnC,eAAemC,OAAO;AAC9B;AAEA,eAAeH;IACb,MAAMI,UAAUnC;IAChB,MAAMoC,aAAa;IAEnBC,QAAQC,GAAG,CAACxD,MAAMyD,MAAM,CAACC,IAAI,CAAC;IAE9B,MAAMC,gBAAgBpD,MACpB,cACA;QACE;QACA;QACA;QACA;QACA+C;KACD,EACD;QACEM,KAAKP;QACLQ,OAAO;QACPC,KAAK;YACH,GAAGlD,QAAQkD,GAAG;YACdC,UAAU;YACVC,KAAK;YACLC,eAAeZ;QACjB;IACF;IAGF,QAAQ;IACR,MAAMa,UAAU;QACdX,QAAQC,GAAG,CAACxD,MAAMyD,MAAM,CAAC;QACzBE,cAAcQ,IAAI,CAAC;QACnBvD,QAAQwD,IAAI,CAAC;IACf;IAEAxD,QAAQyD,EAAE,CAAC,UAAUH;IACrBtD,QAAQyD,EAAE,CAAC,WAAWH;IAEtBP,cAAcU,EAAE,CAAC,QAAQ,CAACC;QACxB,IAAIA,SAAS,GAAG;YACdf,QAAQgB,KAAK,CAACvE,MAAMwE,GAAG,CAAC,CAAC,0BAA0B,EAAEF,MAAM;YAC3D1D,QAAQwD,IAAI,CAACE,QAAQ;QACvB;IACF;AACF;AAEA,eAAepB;IACb,MAAMI,aAAa;IAEnB,IAAI,CAAE,MAAM3C,OAAO2C,aAAc;QAC/BC,QAAQC,GAAG,CACTxD,MAAMwE,GAAG,CAAC,GAAGlB,WAAW,4CAA4C,CAAC;QAEvEC,QAAQC,GAAG,CAACxD,MAAMyE,IAAI,CAAC;QACvB;IACF;IAEA,MAAM,EAAElE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC;IAC/B,MAAMoD,gBAAgBpD,MACpB,QACA;QAAC;QAAwB;QAAM;QAAiB+C;KAAW,EAC3D;QACEM,KAAK/C,OAAO6D,WAAW;QACvBb,OAAO;IACT;IAGFjD,QAAQyD,EAAE,CAAC,UAAU;QACnBV,cAAcQ,IAAI,CAAC;QACnBvD,QAAQwD,IAAI,CAAC;IACf;AACF;AAEA,eAAeO;IACb,WAAW;IACXxD,WAAW,IAAIH,SAAS;QACtB4D,MAAM;IACR;AACF;AAEA,eAAeC;IACb5D,eAAeK,IAAI;AACrB;AAEA,eAAea;IACb,MAAMwC;IAEN,MAAMxD,SAAS2D,GAAG;AACpB;AAEA,eAAe1C;IACb,MAAMuC;IAEN,MAAMxD,SAAS4D,KAAK;AACtB;AAEA,eAAevC;IACb,MAAMmC;IAEN,MAAMK,SAAS,MAAM7D,SAAS8D,SAAS;IACvC,UAAU;IACV1B,QAAQC,GAAG,CAACwB;AACd;AAEA,eAAe3C;IACb,MAAMsC;IAEN,MAAMxD,SAAS+D,QAAQ;AACzB;AAEA,eAAe5C;IACb,MAAMqC;IAEN,MAAMxD,SAASgE,gBAAgB;AACjC;AAEA,eAAe5C;IACb,MAAMoC;IAEN,MAAMxD,SAASiE,QAAQ;AACzB;AAEA,eAAe3C;IACb,MAAM4C,YAAYxE,OAAOyE,QAAQ,CAACC,kBAAkB;IACpD,MAAMC,UAAU;QACd;YACEC,OAAO;YACPvF,QAAQW,OAAOyE,QAAQ,CAACI,cAAc;QACxC;QACA;YACED,OAAO;YACPvF,QAAQW,OAAOyE,QAAQ,CAACK,aAAa;YACrCC,QAAQ,AAAC,CAAA;gBACP,MAAMC,aAAahF,OAAOyE,QAAQ,CAACI,cAAc,CAC9CI,UAAU;gBACb,MAAMC,YAAYlF,OAAOyE,QAAQ,CAACK,aAAa,CAC5CG,UAAU;gBACb,OACED,WAAWG,IAAI,KAAKD,UAAUC,IAAI,IAClCH,WAAWI,QAAQ,KAAKF,UAAUE,QAAQ;YAE9C,CAAA;QACF;QACA;YACER,OAAO;YACPvF,QAAQW,OAAOyE,QAAQ,CAACY,IAAI;QAC9B;KACD;IAMD,kBAAkB;IAClB3C,QAAQC,GAAG,CAAC;IACZ,MAAM2C,eAAe,CAAC,yBAAyB,EAAEC,KAAKC,GAAG,GAAG,IAAI,CAAC;IACjE,MAAMC,UAAUjB,UAAUS,UAAU;IACpC,MAAMS,iBAAiB,CAAC,oCAAoC,EAAEH,KAAKC,GAAG,GAAG,IAAI,CAAC;IAC9E/F,SACE,CAAC,YAAY,EAAEgG,QAAQN,IAAI,CAAC,GAAG,EAAEM,QAAQE,IAAI,CAAC,GAAG,EAAEF,QAAQG,QAAQ,CAAC,mDAAmD,EAAEH,QAAQL,QAAQ,CAAC,GAAG,EAAEE,cAAc;IAE/J,MAAMO,MAAM5F,KAAKuE;IACjB,MAAM,CAAC,CAACsB,WAAW,CAAC,GAAG,MAAMD,IAAIE,GAAG,CAClC,qHACA;QAACN,QAAQL,QAAQ;KAAC;IAEpB,IAAIU,WAAWE,KAAK,GAAG,GAAG;QACxBvG,SACE,CAAC,YAAY,EAAEgG,QAAQN,IAAI,CAAC,GAAG,EAAEM,QAAQE,IAAI,CAAC,GAAG,EAAEF,QAAQG,QAAQ,CAAC,gDAAgD,EAAEH,QAAQL,QAAQ,CAAC,wCAAwC,EAAEM,gBAAgB;IAErM;IAEA,+BAA+B;IAC/B,WAAW,MAAM,EAAEd,KAAK,EAAEvF,MAAM,EAAE0F,MAAM,EAAE,IAAIJ,QAAS;QACrD,MAAMsB,OAAO5G,OAAO4F,UAAU;QAE9B,IAAIF,WAAW,MAAM;YACnBrC,QAAQC,GAAG,CAACxD,MAAMwE,GAAG,CAAC,GAAGiB,MAAM,UAAU,CAAC;YAC1C;QACF;QAEA,MAAMsB,KAAKjG,KAAK;YACd,GAAGZ,MAAM;YACT4F,YAAY;gBACV,GAAK5F,OAAO4F,UAAU,IAAI,CAAC,CAAC;gBAC5BG,UAAUe;YACZ;QACF;QACA,MAAM,CAAC,CAACC,IAAI,CAAC,GAAG,MAAMF,GAAGH,GAAG,CAAC,CAAC,qBAAqB,EAAEE,KAAKb,QAAQ,CAAC,CAAC,CAAC;QACrE,IAAIgB,KAAK;YACP1D,QAAQC,GAAG,CACTxD,MAAMyD,MAAM,CAAC,GAAGgC,MAAM,YAAY,EAAEqB,KAAKb,QAAQ,CAAC,gBAAgB,CAAC;YAErE,MAAMc,GAAG3D,OAAO;YAChB;QACF;QAEAG,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEiC,MAAM,GAAG,CAAC;QACjC,MAAMyB,WAAW,CAAC,QAAQ,EAAEJ,KAAKd,IAAI,CAAC,GAAG,EAAEc,KAAKN,IAAI,CAAC,GAAG,EAAEM,KAAKL,QAAQ,EAAE;QACzEnG,SAAS,GAAG4G,SAAS,+BAA+B,EAAEJ,KAAKb,QAAQ,CAAC,GAAG,CAAC;QACxE3F,SAAS,GAAG4G,SAAS,uBAAuB,EAAEJ,KAAKb,QAAQ,CAAC,GAAG,CAAC;QAChE3F,SAAS,GAAG4G,SAAS,CAAC,EAAEJ,KAAKb,QAAQ,CAAC,GAAG,EAAEE,cAAc;QACzD,IAAI,MAAMxF,OAAO4F,iBAAiB;YAChCjG,SAAS,GAAG4G,SAAS,CAAC,EAAEJ,KAAKb,QAAQ,CAAC,GAAG,EAAEM,gBAAgB;QAC7D;QAEA,MAAMQ,GAAG3D,OAAO;IAClB;IAEA,MAAMsD,IAAItD,OAAO;AACnB;AAEA,eAAeV,eAAeZ,QAAgB,EAAEqF,SAAmB;IACjE,MAAMtC;IAEN,MAAM5D,eAAemG,aAAa,CAACtF,UAAUqF;IAC7C,MAAMlG,eAAeoG,IAAI;AAC3B;AAEA,eAAe1E;IACb,MAAMkC;IAEN,MAAM5D,eAAeoG,IAAI;AAC3B;AAEA,eAAezE,cAAcnB,IAAY;IACvC,MAAM6F,cAAcnH,KAAKoH,IAAI,CAAC1G,OAAO6D,WAAW,EAAE,OAAO;IACzD,MAAM8C,YAAY,MAAM/G,QAAQ6G;IAEhC,MAAMG,WAAW,MAAM,AAAC,CAAA;QACtB,IAAI,CAAE,MAAM9G,OAAO2G,cAAe;YAChC,MAAM9G,MAAM8G,aAAa;gBAAEI,WAAW;YAAK;QAC7C;QAEA,MAAMC,eAAeH,UAClBI,MAAM,CACL,CAACC,WAAaA,SAASC,UAAU,CAAC,QAAQD,SAASE,QAAQ,CAAC,QAE7DlG,GAAG,CAAC,CAACgG;YACJ,MAAM,GAAGG,MAAM,GAAGH,SAASI,KAAK,CAAC,mBAAmB;gBAAC;gBAAK;aAAI;YAC9D,OAAOC,SAASF;QAClB,GACCG,IAAI,CAAC,CAACC,GAAGC,IAAMA,IAAID;QAEtB,IAAIT,aAAaW,MAAM,GAAG,GAAG;YAC3B,OAAOX,YAAY,CAAC,EAAE;QACxB;QAEA,OAAO;IACT,CAAA;IAEA,MAAMY,eAAed,WAAW;IAChC,MAAMI,WAAW,CAAC,CAAC,EAAEU,aAAa,CAAC,EAAE9G,KAAK,GAAG,CAAC;IAC9C,MAAM+G,UAAUrI,KAAKoH,IAAI,CAACD,aAAaO;IAEvC,MAAMvD,OAAO;QACX,CAAC,gCAAgC,CAAC;QAClC;QACA,CAAC,gBAAgB,CAAC;QAClB,CAAC,aAAa,EAAEuD,SAAS,GAAG,CAAC;QAC7B;QACA,CAAC,8BAA8B,CAAC;QAChC,CAAC,QAAQ,CAAC;QACV,CAAC,GAAG,CAAC;QACL;KACD,CAACN,IAAI,CAAC;IACP,MAAM7G,UAAU8H,SAASlE;IAEzBhE,SAAS,CAAC,KAAK,EAAEkI,SAAS;IAE1B,MAAMC,UAAU,CAAC,+DAA+D,EAAEZ,SAASa,OAAO,CAChG,OACA,QACC;IACHnF,QAAQC,GAAG,CAAC,GAAGxD,MAAMyE,IAAI,CAACgE,SAAS,qBAAqB,CAAC;IACzDnI,SAAS,CAAC,MAAM,EAAEmI,QAAQ,UAAU,CAAC;AACvC;AAEA,eAAe5F,YAAYf,QAAgB;IACzC,MAAMjB,OAAO8H,MAAM,CAACC,YAAY,CAAC;QAAE9G;IAAS;AAC9C;AAEA,eAAegB,eAAehB,QAAgB;IAC5C,MAAMjB,OAAO8H,MAAM,CAACE,gBAAgB,CAAC,SAAS;QAC5C/G;IACF;AACF;AAEA,eAAeiB,oBAAoBjB,QAAgB;IACjD,MAAMjB,OAAO8H,MAAM,CAACE,gBAAgB,CAAC,cAAc;QACjD/G;IACF;AACF;AAEA,eAAekB;IACb,IAAI;QACF,uCAAuC;QACvC,MAAM8F,eAAe,MAAM,YAAYC,OAAO,CAAC;QAC/C,MAAMC,aAAa7I,KAAKoH,IAAI,CAC1BpH,KAAK8I,OAAO,CAAC7I,cAAc0I,gBAC3B;QAGF,IAAI,CAAE,MAAMnI,OAAOqI,aAAc;YAC/BzF,QAAQC,GAAG,CACTxD,MAAMwE,GAAG,CACP,CAAC,8BAA8B,EAAEwE,WAAW,gCAAgC,CAAC;YAGjF;QACF;QAEA,iCAAiC;QACjC,MAAME,YAAY3I,MAChBK,QAAQuI,QAAQ,EAChB;YACE;YAAY;YACZ;YAAY;YACZ;YACA;YACAH;SACD,EACD;YACEnF,OAAO;YACPC,KAAK;gBACH,GAAGlD,QAAQkD,GAAG;gBACdE,KAAK;gBACLoF,cACEvI,OAAOX,MAAM,CAACmJ,WAAW,IAAIlJ,KAAKmJ,QAAQ,CAACzI,OAAO6D,WAAW;gBAC/DT,eAAepD,OAAO6D,WAAW;gBACjC6E,SAAS,AAAC1I,CAAAA,OAAOX,MAAM,CAAC8C,EAAE,EAAEwG,QAAQ,KAAI,EAAGC,QAAQ;YACrD;QACF;QAGF,QAAQ;QACR,MAAMvF,UAAU;YACdX,QAAQC,GAAG,CAACxD,MAAMyD,MAAM,CAAC;YACzByF,UAAU/E,IAAI,CAAC;YACfvD,QAAQwD,IAAI,CAAC;QACf;QAEAxD,QAAQyD,EAAE,CAAC,UAAUH;QACrBtD,QAAQyD,EAAE,CAAC,WAAWH;QAEtBgF,UAAU7E,EAAE,CAAC,QAAQ,CAACC;YACpB,IAAIA,SAAS,GAAG;gBACdf,QAAQgB,KAAK,CAACvE,MAAMwE,GAAG,CAAC,CAAC,6BAA6B,EAAEF,MAAM;gBAC9D1D,QAAQwD,IAAI,CAACE,QAAQ;YACvB;QACF;IACF,EAAE,OAAOoF,GAAY;QACnB,IAAIA,aAAaC,SAASD,EAAEhI,OAAO,CAACkI,QAAQ,CAAC,mBAAmB;YAC9DrG,QAAQC,GAAG,CACT,CAAC,oBAAoB,EAAExD,MAAMyE,IAAI,CAAC,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;YAE9D;QACF;QACA,MAAMiF;IACR;AACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bin/cli.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dotenv from \"dotenv\";\n\ndotenv.config();\n\nimport { execSync, spawn } from \"child_process\";\nimport { mkdir, readdir, rm, writeFile } from \"fs/promises\";\nimport knex, { type Knex } from \"knex\";\nimport { createRequire } from \"module\";\nimport path from \"path\";\nimport process from \"process\";\nimport { tsicli } from \"tsicli\";\nimport { Sonamu } from \"../api\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Migrator } from \"../migration/migrator\";\nimport { FixtureManager } from \"../testing/fixture-manager\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath } from \"../utils/utils\";\nimport { BUILD_DIR, SWC_BUILD_COMMAND, TSC_TYPE_CHECK_COMMAND } from \"./build-config\";\n\nlet migrator: Migrator;\n\nasync function bootstrap() {\n  const notToInit = [\"dev\", \"build\", \"start\"].includes(process.argv[2] ?? \"\");\n  if (!notToInit) {\n    await Sonamu.init(false, false);\n  }\n\n  await tsicli(process.argv, {\n    types: {\n      \"#entityId\": {\n        type: \"autocomplete\",\n        name: \"#entityId\",\n        message: \"Please input #entityId\",\n        choices: EntityManager.getAllParentIds().map((entityId) => ({\n          title: entityId,\n          value: entityId,\n        })),\n      },\n      \"#recordIds\": \"number[]\",\n      \"#name\": \"string\",\n    },\n    args: [\n      [\"fixture\", \"init\"],\n      [\"fixture\", \"import\", \"#entityId\", \"#recordIds\"],\n      [\"fixture\", \"sync\"],\n      [\"migrate\", \"run\"],\n      [\"migrate\", \"check\"],\n      [\"migrate\", \"rollback\"],\n      [\"migrate\", \"reset\"],\n      [\"migrate\", \"clear\"],\n      [\"migrate\", \"status\"],\n      [\"stub\", \"practice\", \"#name\"],\n      [\"stub\", \"entity\", \"#name\"],\n      [\"scaffold\", \"model\", \"#entityId\"],\n      [\"scaffold\", \"model_test\", \"#entityId\"],\n      [\"scaffold\", \"view_list\", \"#entityId\"],\n      [\"scaffold\", \"view_form\", \"#entityId\"],\n      [\"ui\"],\n      [\"sync\"],\n      [\"dev\"],\n      [\"build\"],\n      [\"start\"],\n    ],\n    runners: {\n      migrate_status,\n      migrate_run,\n      fixture_init,\n      fixture_import,\n      fixture_sync,\n      stub_practice,\n      stub_entity,\n      scaffold_model,\n      scaffold_model_test,\n      ui,\n      // scaffold_view_list,\n      // scaffold_view_form,\n      sync,\n      dev,\n      build,\n      start,\n    },\n  });\n}\n\nbootstrap().finally(async () => {\n  await FixtureManager.destroy();\n});\n\n/**\n * pnpm sync 하면 실행되는 함수입니다.\n * 프로젝트를 싱크합니다.\n */\nasync function sync() {\n  await Sonamu.syncer.sync();\n}\n\n/**\n * pnpm dev 하면 실행되는 함수입니다.\n * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.\n *\n * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/loader를,\n * HMR을 지원하기 위해 @sonamu-kit/hot-hook을 import하며,\n * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.\n *\n * 이때 @sonamu-kit/loader와 @sonamu-kit/hot-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 또한 실행에 사용하는 @sonamu-kit/hot-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function dev() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"src/index.ts\";\n\n  console.log(chalk.yellow.bold(\"🚀 Starting Sonamu dev server...\\n\"));\n\n  // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hot-runner의 bin/run.js를 사용합니다.\n  // 이 경로(/bin/run.js)는 @sonamu-kit/hot-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.\n  const hotRunnerBinPath = createRequire(import.meta.url).resolve(\n    \"@sonamu-kit/hot-runner/bin/run.js\",\n  );\n\n  const serverProcess = spawn(\n    process.execPath, // node\n    [\n      hotRunnerBinPath, // 이렇게 해서 hot-runner를 실행하구요\n      \"--clear-screen=false\", // 이하 hot-runner에게 넘겨줄 인자들입니다.\n      \"--node-args=--import=sonamu/loader-register\", // TypeScript 서포트를 위한 로더,\n      \"--node-args=--import=sonamu/hot-hook-register\", // HMR을 지원하기 위한 hot-hook,\n      \"--node-args=--enable-source-maps\", // 그리고 소스맵 지원을 위한 플래그입니다.\n      \"--on-key=r:restart:Restart server\", // r 누르면 서버 재시작하게 해줘요.\n      `--on-key=f:shell(rm ${path.join(apiRoot, \"sonamu.lock\")}):restart:Force restart`, // f 누르면 sonamu.lock 파일을 지우고 서버 재시작하게 해줘요.\n\n      \"--on-key=enter:shell(echo hi):Key binding test\", // enter를 key로 쓸 수 있음을 보이기 위한 테스트입니다.\n      \"--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart\", // modifier와의 조합, 그리고 두 개의 chord를 사용할 수 있음을 보이기 위한 테스트입니다.\n      entryPoint, // 마지막으로 실제 실행할 스크립트의 경로를 넘겨줍니다.\n    ],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n      env: {\n        ...process.env,\n        NODE_ENV: \"development\",\n        HOT: \"yes\", // 얘가 있어야 HMR이 활성화됩니다.\n        API_ROOT_PATH: apiRoot, // 이 경로가 hot-hook의 루트 디렉토리가 됩니다.\n      },\n    },\n  );\n\n  // 종료 처리\n  const cleanup = () => {\n    console.log(chalk.yellow(\"\\n\\n👋 Shutting down...\"));\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  };\n\n  process.on(\"SIGINT\", cleanup);\n  process.on(\"SIGTERM\", cleanup);\n\n  serverProcess.on(\"exit\", (code) => {\n    if (code !== 0) {\n      console.error(chalk.red(`❌ Server exited with code ${code}`));\n      process.exit(code || 1);\n    }\n  });\n}\n\n/**\n * pnpm build 하면 실행되는 함수입니다.\n * 프로젝트를 빌드합니다.\n *\n * 빌드에 필요한 .swcrc는 프로젝트 루트에서 찾고, 없으면 sonamu가 관리하는 .swcrc.project-default를 사용합니다.\n * sonamu.config.ts는 src에 들어있지 않기 때문에 SWC_BUILD_COMMAND로 빌드되지 않습니다.\n * 따라서 따로 빌드해줍니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build() {\n  const apiRoot = findApiRootPath();\n\n  // 출력 디렉토리를 제거합니다.\n  try {\n    console.log(chalk.blue(\"Removing build directory...\"));\n    if (await exists(BUILD_DIR)) {\n      await rm(BUILD_DIR, { recursive: true, force: true });\n    }\n  } catch (error) {\n    console.error(chalk.red(\"Remove build directory failed.\"), error);\n    process.exit(1);\n  }\n\n  // .swcrc 파일을 지정합니다.\n  let swcFilePath = \".swcrc\";\n  try {\n    if (await exists(swcFilePath)) {\n      // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.\n      console.log(chalk.blue(\"Using .swcrc from project root...\"));\n    } else {\n      // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.\n      console.log(chalk.blue(\"Using default .swcrc from sonamu package...\"));\n      swcFilePath = path.join(import.meta.dirname, \"..\", \"..\", \".swcrc.project-default\");\n    }\n  } catch (error) {\n    console.error(chalk.red(\"Setting up swc config file failed.\"), error);\n    process.exit(1);\n  }\n\n  // 소스 디렉토리를 빌드합니다.\n  try {\n    console.log(chalk.blue(\"Building with swc...\"));\n    execSync(SWC_BUILD_COMMAND(swcFilePath), { cwd: apiRoot, stdio: \"inherit\" });\n  } catch (error) {\n    console.error(chalk.red(\"Build failed.\"), error);\n    process.exit(1);\n  }\n\n  // sonamu.config.ts만 따로 빌드합니다.\n  // 이 친구는 src에 들어있지 않기 때문에 SWC_BUILD_COMMAND로 빌드되지 않습니다.\n  // 따라서 따로 빌드해줍니다.\n  try {\n    const configPath = path.join(apiRoot, \"sonamu.config.ts\");\n    if (await exists(configPath)) {\n      console.log(chalk.blue(\"Building sonamu.config.ts...\"));\n      execSync(`swc ${configPath} -o ${BUILD_DIR}/sonamu.config.js`, {\n        cwd: apiRoot,\n        stdio: \"inherit\",\n      });\n    }\n  } catch (error) {\n    console.error(chalk.red(\"Building sonamu.config.ts failed.\"), error);\n    process.exit(1);\n  }\n\n  // 마지막에는 타입 체크를 해요.\n  try {\n    console.log(chalk.blue(\"Checking types with tsc...\"));\n    execSync(TSC_TYPE_CHECK_COMMAND, {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n    });\n  } catch (error) {\n    console.error(chalk.red(\"Type check failed.\"), error);\n    process.exit(1);\n  }\n}\n\n/**\n * pnpm start 하면 실행되는 함수입니다.\n * 빌드된 프로젝트를 실행합니다.\n *\n * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.\n * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function start() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"dist/index.js\";\n\n  if (!(await exists(entryPoint))) {\n    console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));\n    console.log(chalk.blue(\"Run: yarn sonamu build\"));\n    return;\n  }\n\n  const { spawn } = await import(\"child_process\");\n  const serverProcess = spawn(\n    process.execPath,\n    [\"--enable-source-maps\", \"-r\", \"dotenv/config\", entryPoint],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n    },\n  );\n\n  process.on(\"SIGINT\", () => {\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  });\n}\n\nasync function setupMigrator() {\n  // migrator\n  migrator = new Migrator();\n}\n\nasync function setupFixtureManager() {\n  FixtureManager.init();\n}\n\nasync function migrate_run() {\n  await setupMigrator();\n\n  await migrator.runAction(\n    \"apply\",\n    Object.keys(Sonamu.dbConfig) as (keyof SonamuDBConfig)[] /*싹 다!*/,\n  );\n}\n\nasync function migrate_status() {\n  await setupMigrator();\n\n  const status = await migrator.getStatus();\n  // status;\n  console.log(status);\n}\n\nasync function fixture_init() {\n  const srcConfig = Sonamu.dbConfig.development_master;\n  const targets = [\n    {\n      label: \"(REMOTE) Fixture DB\",\n      config: Sonamu.dbConfig.fixture_remote,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture_remote.connection as Knex.ConnectionConfig;\n        const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;\n        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;\n      })(),\n    },\n  ] as {\n    label: string;\n    config: Knex.Config;\n    toSkip?: boolean;\n  }[];\n\n  // 1. 기준DB 스키마를 덤프\n  console.log(\"DUMP...\");\n  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;\n  const srcConn = srcConfig.connection as Knex.ConnectionConfig;\n  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;\n  execSync(\n    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`,\n  );\n  const _db = knex(srcConfig);\n  const [[migrations]] = await _db.raw(\n    \"SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'\",\n    [srcConn.database],\n  );\n  if (migrations.count > 0) {\n    execSync(\n      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`,\n    );\n  }\n\n  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기\n  for await (const { label, config, toSkip } of targets) {\n    const conn = config.connection as Knex.ConnectionConfig;\n\n    if (toSkip === true) {\n      console.log(chalk.red(`${label}: Skipped!`));\n      continue;\n    }\n\n    const db = knex({\n      ...config,\n      connection: {\n        ...((config.connection ?? {}) as Knex.ConnectionConfig),\n        database: undefined,\n      },\n    });\n    const [[row]] = await db.raw(`SHOW DATABASES LIKE \"${conn.database}\"`);\n    if (row) {\n      console.log(chalk.yellow(`${label}: Database \"${conn.database}\" Already exists`));\n      await db.destroy();\n      continue;\n    }\n\n    console.log(`SYNC to ${label}...`);\n    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;\n    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} -e 'CREATE DATABASE \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);\n    if (await exists(migrationsDump)) {\n      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);\n    }\n\n    await db.destroy();\n  }\n\n  await _db.destroy();\n}\n\nasync function fixture_import(entityId: string, recordIds: number[]) {\n  await setupFixtureManager();\n\n  await FixtureManager.importFixture(entityId, recordIds);\n  await FixtureManager.sync();\n}\n\nasync function fixture_sync() {\n  await setupFixtureManager();\n\n  await FixtureManager.sync();\n}\n\nasync function stub_practice(name: string) {\n  const practiceDir = path.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  const fileNames = await readdir(practiceDir);\n\n  const maxSeqNo = await (async () => {\n    if (!(await exists(practiceDir))) {\n      await mkdir(practiceDir, { recursive: true });\n    }\n\n    const filteredSeqs = fileNames\n      .filter((fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\"))\n      .map((fileName) => {\n        const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [\"0\", \"0\"];\n        return parseInt(seqNo);\n      })\n      .sort((a, b) => b - a);\n\n    if (filteredSeqs.length > 0) {\n      return filteredSeqs[0];\n    }\n\n    return 0;\n  })();\n\n  const currentSeqNo = maxSeqNo + 1;\n  const fileName = `p${currentSeqNo}-${name}.ts`;\n  const dstPath = path.join(practiceDir, fileName);\n\n  const code = [\n    `import { Sonamu } from \"sonamu\";`,\n    \"\",\n    `console.clear();`,\n    `console.log(\"${fileName}\");`,\n    \"\",\n    `Sonamu.runScript(async () => {`,\n    ` // TODO`,\n    `});`,\n    \"\",\n  ].join(\"\\n\");\n  await writeFile(dstPath, code);\n\n  execSync(`code ${dstPath}`);\n\n  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(\n    \".ts\",\n    \".js\",\n  )}`;\n  console.log(`${chalk.blue(runCode)} copied to clipboard.`);\n  execSync(`echo \"${runCode}\" | pbcopy`);\n}\n\nasync function stub_entity(entityId: string) {\n  await Sonamu.syncer.createEntity({ entityId, title: entityId });\n}\n\nasync function scaffold_model(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model\", {\n    entityId,\n  });\n}\n\nasync function scaffold_model_test(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model_test\", {\n    entityId,\n  });\n}\n\nasync function ui() {\n  try {\n    // 사용자 프로젝트의 패키지들 중에서 @sonamu-kit/ui를 찾습니다.\n    // 이를 위해서 createRequire를 사용하여 프로젝트 경로 기준으로 resolve합니다.\n    const projectRequire = createRequire(path.join(Sonamu.apiRootPath, \"package.json\"));\n    const uiPackagePath = projectRequire.resolve(\"@sonamu-kit/ui\"); // 없으면 여기서 터져요(MODULE_NOT_FOUND)\n    const uiNodePath = path.join(path.dirname(uiPackagePath), \"run-ui.js\");\n\n    if (!(await exists(uiNodePath))) {\n      console.log(\n        chalk.red(`UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`),\n      );\n      return;\n    }\n\n    // UI를 별도 프로세스로 실행 (hot-hook 활성화)\n    const uiProcess = spawn(\n      process.execPath,\n      [\n        \"--import\",\n        \"sonamu/loader-register\",\n        \"--import\",\n        \"sonamu/hot-hook-register\",\n        \"--enable-source-maps\",\n        \"--no-warnings\",\n        uiNodePath,\n      ],\n      {\n        stdio: \"inherit\",\n        env: {\n          ...process.env,\n          HOT: \"yes\",\n          PROJECT_NAME: Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),\n          API_ROOT_PATH: Sonamu.apiRootPath,\n          UI_PORT: (Sonamu.config.ui?.port ?? 57000).toString(),\n        },\n      },\n    );\n\n    // 종료 처리\n    const cleanup = () => {\n      console.log(chalk.yellow(\"\\n\\n👋 Shutting down UI server...\"));\n      uiProcess.kill(\"SIGTERM\");\n      process.exit(0);\n    };\n\n    process.on(\"SIGINT\", cleanup);\n    process.on(\"SIGTERM\", cleanup);\n\n    uiProcess.on(\"exit\", (code) => {\n      if (code !== 0) {\n        console.error(chalk.red(`❌ UI server exited with code ${code}`));\n        process.exit(code || 1);\n      }\n    });\n  } catch (e: unknown) {\n    if (e instanceof Error && e.message.includes(\"isn't declared\")) {\n      console.log(`You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`);\n      return;\n    }\n    throw e;\n  }\n}\n"],"names":["chalk","dotenv","config","execSync","spawn","mkdir","readdir","rm","writeFile","knex","createRequire","path","process","tsicli","Sonamu","EntityManager","Migrator","FixtureManager","exists","findApiRootPath","BUILD_DIR","SWC_BUILD_COMMAND","TSC_TYPE_CHECK_COMMAND","migrator","bootstrap","notToInit","includes","argv","init","types","type","name","message","choices","getAllParentIds","map","entityId","title","value","args","runners","migrate_status","migrate_run","fixture_init","fixture_import","fixture_sync","stub_practice","stub_entity","scaffold_model","scaffold_model_test","ui","sync","dev","build","start","finally","destroy","syncer","apiRoot","entryPoint","console","log","yellow","bold","hotRunnerBinPath","url","resolve","serverProcess","execPath","join","cwd","stdio","env","NODE_ENV","HOT","API_ROOT_PATH","cleanup","kill","exit","on","code","error","red","blue","recursive","force","swcFilePath","dirname","configPath","setupMigrator","setupFixtureManager","runAction","Object","keys","dbConfig","status","getStatus","srcConfig","development_master","targets","label","fixture_remote","test","toSkip","remoteConn","connection","localConn","host","database","dumpFilename","Date","now","srcConn","migrationsDump","user","password","_db","migrations","raw","count","conn","db","undefined","row","mysqlCmd","recordIds","importFixture","practiceDir","apiRootPath","fileNames","maxSeqNo","filteredSeqs","filter","fileName","startsWith","endsWith","seqNo","match","parseInt","sort","a","b","length","currentSeqNo","dstPath","runCode","replace","createEntity","generateTemplate","projectRequire","uiPackagePath","uiNodePath","uiProcess","PROJECT_NAME","projectName","basename","UI_PORT","port","toString","e","Error"],"mappings":"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"}

package/dist/bin/loader-register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=loader-register.d.ts.map