sonamu 0.7.34 → 0.7.35

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

@@ -1,30 +1,21 @@
+export type BuildArtifact<BuildCommandArgs = {}> = {
+    name: string;
+    description: string;
+    projectPath: string;
+    preBuildCommand?: () => string;
+    buildCommand: (args: BuildCommandArgs) => string;
+    postBuildCommand?: () => string;
+};
 /**
  * API 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
- *
- * 경로(projectPath, outputDir, destDir)는 app root에서 시작하는 상대경로로 작성되어 있습니다.
- * 다만 buildCommand는 projectPath를 기준으로 실행됩니다.
  */
-export declare const API_ARTIFACTS: {
-    name: string;
-    description: string;
-    projectPath: string;
-    buildCommand: (configFilePath: string) => string;
-    outputDir: string;
-}[];
+export declare const API_ARTIFACTS: BuildArtifact<{
+    configFilePath: string;
+}>[];
 /**
  * 웹 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
- *
- * 경로(projectPath, outputDir, destDir)는 app root에서 시작하는 상대경로로 작성되어 있습니다.
- * 다만 buildCommand는 projectPath를 기준(cwd)으로 실행됩니다.
  */
-export declare const WEB_ARTIFACTS: {
-    name: string;
-    description: string;
-    projectPath: string;
-    buildCommand: () => string;
-    outputDir: string;
-    destDir: string;
-}[];
+export declare const WEB_ARTIFACTS: BuildArtifact[];
 //# sourceMappingURL=build-config.d.ts.map

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;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;mCAKS,MAAM;;GAIxC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;GAiBzB,CAAC"}
+{"version":3,"file":"build-config.d.ts","sourceRoot":"","sources":["../../src/bin/build-config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,CAAC,gBAAgB,GAAG,EAAE,IAAI;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,MAAM,CAAC;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,MAAM,CAAC;IACjD,gBAAgB,CAAC,EAAE,MAAM,MAAM,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC,EASpE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,aAAa,EAkBxC,CAAC"}

package/dist/bin/build-config.js

@@ -1,41 +1,35 @@
 /**
  * API 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
- *
- * 경로(projectPath, outputDir, destDir)는 app root에서 시작하는 상대경로로 작성되어 있습니다.
- * 다만 buildCommand는 projectPath를 기준으로 실행됩니다.
  */ export const API_ARTIFACTS = [
     {
         name: "API",
         description: "API 프로젝트 빌드 산출물",
         projectPath: "api",
-        buildCommand: (configFilePath)=>`tsc --noEmit && swc src -d dist --config-file ${configFilePath} --strip-leading-paths`,
-        outputDir: "api/dist"
+        preBuildCommand: ()=>"rm -rf dist",
+        buildCommand: ({ configFilePath })=>`tsc --noEmit && swc src -d dist --config-file ${configFilePath} --strip-leading-paths`
     }
 ];
 /**
  * 웹 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
- *
- * 경로(projectPath, outputDir, destDir)는 app root에서 시작하는 상대경로로 작성되어 있습니다.
- * 다만 buildCommand는 projectPath를 기준(cwd)으로 실행됩니다.
  */ export const WEB_ARTIFACTS = [
     {
         name: "Web Client",
         description: "Web 프로젝트 클라이언트 빌드 산출물",
         projectPath: "web",
-        buildCommand: ()=>"tsc && vite build --outDir dist/client",
-        outputDir: "web/dist/client",
-        destDir: "api/public/web"
+        preBuildCommand: ()=>"rm -rf dist/client && rm -rf ../api/public/web",
+        buildCommand: ()=>"tsc --noEmit && vite build --outDir dist/client",
+        postBuildCommand: ()=>"mkdir -p ../api/public/web && cp -r dist/client/* ../api/public/web"
     },
     {
         name: "Web Server",
         description: "Web 프로젝트 서버 빌드 산출물",
         projectPath: "web",
-        buildCommand: ()=>"vite build --ssr src/entry-server.generated.tsx --outDir dist/server",
-        outputDir: "web/dist/server",
-        destDir: "api/dist/ssr"
+        preBuildCommand: ()=>"rm -rf dist/server",
+        buildCommand: ()=>"tsc --noEmit && vite build --ssr src/entry-server.generated.tsx --outDir dist/server",
+        postBuildCommand: ()=>"cp -r dist/server/* ../api/dist/ssr"
     }
 ];
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/bin/cli.js

@@ -1,8 +1,9 @@
 import chalk from "chalk";
 import dotenv from "dotenv";
 dotenv.config();
+import assert from "assert";
 import { execSync, spawn } from "child_process";
-import { cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
 import knex from "knex";
 import { createRequire } from "module";
 import path from "path";
@@ -12,7 +13,7 @@ import { Sonamu } from "../api/index.js";
 import { EntityManager } from "../entity/entity-manager.js";
 import { Migrator } from "../migration/migrator.js";
 import { FixtureManager } from "../testing/fixture-manager.js";
-import { execWithLinePrefix, printBuildSummary, printTaskFailed, printTaskHeader, printTaskSkipped, printTaskStart, printTaskSuccess } from "../utils/console-util.js";
+import { execWithLinePrefix, printBuildSummary, printTaskFailed, printTaskHeader, printTaskStart, printTaskSuccess } from "../utils/console-util.js";
 import { exists } from "../utils/fs-utils.js";
 import { findApiRootPath, findAppRootPath } from "../utils/utils.js";
 import { API_ARTIFACTS, WEB_ARTIFACTS } from "./build-config.js";
@@ -222,38 +223,6 @@ bootstrap().finally(async ()=>{
  * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
  */ async function build() {
     const appRoot = findAppRootPath();
-    // 출력 디렉토리를 제거합니다.
-    try {
-        for (const artifact of API_ARTIFACTS){
-            if (await exists(path.join(appRoot, artifact.outputDir))) {
-                // API 프로젝트 자체의 빌드 결과물
-                await rm(path.join(appRoot, artifact.outputDir), {
-                    recursive: true,
-                    force: true
-                });
-            }
-        }
-        for (const artifact of WEB_ARTIFACTS){
-            if (await exists(path.join(appRoot, artifact.outputDir))) {
-                // Web 프로젝트 자체의 빌드 결과물
-                await rm(path.join(appRoot, artifact.outputDir), {
-                    recursive: true,
-                    force: true
-                });
-            }
-            if (await exists(path.join(appRoot, artifact.destDir))) {
-                // API 프로젝트로 복사되어 온 Web 빌드 결과물
-                await rm(path.join(appRoot, artifact.destDir), {
-                    recursive: true,
-                    force: true
-                });
-            }
-        }
-        console.log(chalk.green("\nBuild artifacts removed successfully."));
-    } catch (error) {
-        console.error(chalk.red("Remove build directories failed."), error);
-        process.exit(1);
-    }
     // .swcrc 파일을 지정합니다.
     let swcFilePath = ".swcrc";
     try {
@@ -274,20 +243,13 @@ bootstrap().finally(async ()=>{
     try {
         for (const artifact of API_ARTIFACTS){
             const cwd = path.join(appRoot, artifact.projectPath);
-            const cmd = artifact.buildCommand(swcFilePath);
             printTaskHeader(artifact.name, artifact.description, cwd);
-            // build
-            try {
-                printTaskStart("build", cmd, true);
-                // cmd를 spawn해서 build를 수행하는데, 이때 명령의 출력(stdout, stderr) 라인 앞에 들여쓰기를 붙여서 출력합니다.
-                await execWithLinePrefix(cmd, {
-                    cwd
-                });
-                printTaskSuccess("build", true);
-            } catch  {
-                printTaskFailed("build", true);
-                throw new Error("build failed");
-            }
+            await runBuildSteps(artifact, {
+                cwd,
+                buildCommandArgs: {
+                    configFilePath: swcFilePath
+                }
+            });
         }
         printBuildSummary("API", true, Date.now() - apiStartedAt);
     } catch  {
@@ -299,44 +261,11 @@ bootstrap().finally(async ()=>{
     try {
         for (const artifact of WEB_ARTIFACTS){
             const cwd = path.join(appRoot, artifact.projectPath);
-            const cmd = artifact.buildCommand();
-            const outputDirFull = path.join(appRoot, artifact.outputDir);
-            const destDirFull = path.join(appRoot, artifact.destDir);
             printTaskHeader(artifact.name, artifact.description, cwd);
-            // build
-            try {
-                printTaskStart("build", cmd);
-                // cmd를 spawn해서 build를 수행하는데, 이때 명령의 출력(stdout, stderr) 라인 앞에 들여쓰기를 붙여서 출력합니다.
-                await execWithLinePrefix(cmd, {
-                    cwd
-                });
-                printTaskSuccess("build");
-            } catch  {
-                printTaskFailed("build");
-                printTaskSkipped("copy", true);
-                throw new Error("build failed");
-            }
-            // copy
-            try {
-                printTaskStart("copy", `${artifact.outputDir} → ${artifact.destDir}`, true);
-                // Web 아티팩트는 빌드 결과물(outputDir)을 다른 위치(destDir)로 복사하는 작업이 추가로 필요합니다.
-                if (await exists(destDirFull)) {
-                    await rm(destDirFull, {
-                        recursive: true,
-                        force: true
-                    });
-                }
-                await mkdir(destDirFull, {
-                    recursive: true
-                });
-                await cp(outputDirFull, destDirFull, {
-                    recursive: true
-                });
-                printTaskSuccess("copy", true);
-            } catch  {
-                printTaskFailed("copy", true);
-                throw new Error("copy failed");
-            }
+            await runBuildSteps(artifact, {
+                cwd,
+                buildCommandArgs: {}
+            });
         }
         printBuildSummary("Web", true, Date.now() - webStartedAt);
     } catch  {
@@ -344,6 +273,39 @@ bootstrap().finally(async ()=>{
         process.exit(1);
     }
 }
+/**
+ * pre-build, build, post-build 단계를 순차적으로 실행합니다.
+ */ async function runBuildSteps(artifact, options) {
+    const steps = [
+        {
+            name: "pre-build",
+            cmd: artifact.preBuildCommand?.()
+        },
+        {
+            name: "build",
+            cmd: artifact.buildCommand(options.buildCommandArgs)
+        },
+        {
+            name: "post-build",
+            cmd: artifact.postBuildCommand?.()
+        }
+    ].filter((step)=>step.cmd);
+    for(let i = 0; i < steps.length; i++){
+        const step = steps[i];
+        const isLast = i === steps.length - 1;
+        try {
+            assert(step.cmd);
+            printTaskStart(step.name, step.cmd, isLast);
+            await execWithLinePrefix(step.cmd, {
+                cwd: options.cwd
+            });
+            printTaskSuccess(step.name, isLast);
+        } catch  {
+            printTaskFailed(step.name, isLast);
+            throw new Error(`${step.name} failed`);
+        }
+    }
+}
 /**
  * pnpm start 하면 실행되는 함수입니다.
  * 빌드된 프로젝트를 실행합니다.
@@ -521,4 +483,4 @@ async function scaffold_model_test(entityId) {
     });
 }
 
-//# 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 { cp, 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 {\n  execWithLinePrefix,\n  printBuildSummary,\n  printTaskFailed,\n  printTaskHeader,\n  printTaskSkipped,\n  printTaskStart,\n  printTaskSuccess,\n} from \"../utils/console-util\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath, findAppRootPath } from \"../utils/utils\";\nimport { API_ARTIFACTS, WEB_ARTIFACTS } 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  try {\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        [\"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        // scaffold_view_list,\n        // scaffold_view_form,\n        sync,\n        dev,\n        build,\n        start,\n      },\n    });\n  } finally {\n    await Sonamu.destroy();\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/ts-loader를,\n * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,\n * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.\n *\n * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 또한 실행에 사용하는 @sonamu-kit/hmr-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/hmr-runner의 bin/run.js를 사용합니다.\n  // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.\n  const hotRunnerBinPath = createRequire(import.meta.url).resolve(\n    \"@sonamu-kit/hmr-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/ts-loader-register\", // TypeScript 서포트를 위한 로더,\n      \"--node-args=--import=sonamu/hmr-hook-register\", // HMR을 지원하기 위한 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, // 이 경로가 hmr-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 *\n * 실제 빌드 타겟(아티팩트)과 동작은 build-config.ts에 정의되어 있습니다.\n * 이 함수는 build-config.ts에 정의된 동작들을 실행해주는 역할만 합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build() {\n  const appRoot = findAppRootPath();\n\n  // 출력 디렉토리를 제거합니다.\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      if (await exists(path.join(appRoot, artifact.outputDir))) {\n        // API 프로젝트 자체의 빌드 결과물\n        await rm(path.join(appRoot, artifact.outputDir), { recursive: true, force: true });\n      }\n    }\n\n    for (const artifact of WEB_ARTIFACTS) {\n      if (await exists(path.join(appRoot, artifact.outputDir))) {\n        // Web 프로젝트 자체의 빌드 결과물\n        await rm(path.join(appRoot, artifact.outputDir), { recursive: true, force: true });\n      }\n      if (await exists(path.join(appRoot, artifact.destDir))) {\n        // API 프로젝트로 복사되어 온 Web 빌드 결과물\n        await rm(path.join(appRoot, artifact.destDir), { recursive: true, force: true });\n      }\n    }\n\n    console.log(chalk.green(\"\\nBuild artifacts removed successfully.\"));\n  } catch (error) {\n    console.error(chalk.red(\"Remove build directories 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.dim(\"Using .swcrc from project root...\"));\n    } else {\n      // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.\n      console.log(chalk.dim(\"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  // API 프로젝트를 빌드합니다.\n  const apiStartedAt = Date.now();\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      const cmd = artifact.buildCommand(swcFilePath);\n\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      // build\n      try {\n        printTaskStart(\"build\", cmd, true);\n        // cmd를 spawn해서 build를 수행하는데, 이때 명령의 출력(stdout, stderr) 라인 앞에 들여쓰기를 붙여서 출력합니다.\n        await execWithLinePrefix(cmd, { cwd });\n        printTaskSuccess(\"build\", true);\n      } catch {\n        printTaskFailed(\"build\", true);\n        throw new Error(\"build failed\");\n      }\n    }\n    printBuildSummary(\"API\", true, Date.now() - apiStartedAt);\n  } catch {\n    printBuildSummary(\"API\", false, Date.now() - apiStartedAt);\n    process.exit(1);\n  }\n\n  // Web 프로젝트를 빌드합니다.\n  const webStartedAt = Date.now();\n  try {\n    for (const artifact of WEB_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      const cmd = artifact.buildCommand();\n      const outputDirFull = path.join(appRoot, artifact.outputDir);\n      const destDirFull = path.join(appRoot, artifact.destDir);\n\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      // build\n      try {\n        printTaskStart(\"build\", cmd);\n        // cmd를 spawn해서 build를 수행하는데, 이때 명령의 출력(stdout, stderr) 라인 앞에 들여쓰기를 붙여서 출력합니다.\n        await execWithLinePrefix(cmd, { cwd });\n        printTaskSuccess(\"build\");\n      } catch {\n        printTaskFailed(\"build\");\n        printTaskSkipped(\"copy\", true);\n        throw new Error(\"build failed\");\n      }\n\n      // copy\n      try {\n        printTaskStart(\"copy\", `${artifact.outputDir} → ${artifact.destDir}`, true);\n        // Web 아티팩트는 빌드 결과물(outputDir)을 다른 위치(destDir)로 복사하는 작업이 추가로 필요합니다.\n        if (await exists(destDirFull)) {\n          await rm(destDirFull, { recursive: true, force: true });\n        }\n        await mkdir(destDirFull, { recursive: true });\n        await cp(outputDirFull, destDirFull, { recursive: true });\n        printTaskSuccess(\"copy\", true);\n      } catch {\n        printTaskFailed(\"copy\", true);\n        throw new Error(\"copy failed\");\n      }\n    }\n    printBuildSummary(\"Web\", true, Date.now() - webStartedAt);\n  } catch {\n    printBuildSummary(\"Web\", false, Date.now() - webStartedAt);\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,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture.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"],"names":["chalk","dotenv","config","execSync","spawn","cp","mkdir","readdir","rm","writeFile","knex","createRequire","path","process","tsicli","Sonamu","EntityManager","Migrator","FixtureManager","execWithLinePrefix","printBuildSummary","printTaskFailed","printTaskHeader","printTaskSkipped","printTaskStart","printTaskSuccess","exists","findApiRootPath","findAppRootPath","API_ARTIFACTS","WEB_ARTIFACTS","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","sync","dev","build","start","destroy","finally","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","appRoot","artifact","outputDir","recursive","force","destDir","green","swcFilePath","dim","dirname","apiStartedAt","Date","now","projectPath","cmd","buildCommand","description","Error","webStartedAt","outputDirFull","destDirFull","blue","setupMigrator","setupFixtureManager","runAction","Object","keys","dbConfig","status","getStatus","srcConfig","development_master","targets","label","fixture","test","toSkip","remoteConn","connection","localConn","host","database","dumpFilename","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"],"mappings":"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"}
+//# 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 assert from \"assert\";\nimport { execSync, spawn } from \"child_process\";\nimport { mkdir, readdir, 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 {\n  execWithLinePrefix,\n  printBuildSummary,\n  printTaskFailed,\n  printTaskHeader,\n  printTaskStart,\n  printTaskSuccess,\n} from \"../utils/console-util\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath, findAppRootPath } from \"../utils/utils\";\nimport { API_ARTIFACTS, type BuildArtifact, WEB_ARTIFACTS } 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  try {\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        [\"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        // scaffold_view_list,\n        // scaffold_view_form,\n        sync,\n        dev,\n        build,\n        start,\n      },\n    });\n  } finally {\n    await Sonamu.destroy();\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/ts-loader를,\n * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,\n * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.\n *\n * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 또한 실행에 사용하는 @sonamu-kit/hmr-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/hmr-runner의 bin/run.js를 사용합니다.\n  // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.\n  const hotRunnerBinPath = createRequire(import.meta.url).resolve(\n    \"@sonamu-kit/hmr-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/ts-loader-register\", // TypeScript 서포트를 위한 로더,\n      \"--node-args=--import=sonamu/hmr-hook-register\", // HMR을 지원하기 위한 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, // 이 경로가 hmr-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 *\n * 실제 빌드 타겟(아티팩트)과 동작은 build-config.ts에 정의되어 있습니다.\n * 이 함수는 build-config.ts에 정의된 동작들을 실행해주는 역할만 합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build() {\n  const appRoot = findAppRootPath();\n\n  // .swcrc 파일을 지정합니다.\n  let swcFilePath = \".swcrc\";\n  try {\n    if (await exists(swcFilePath)) {\n      // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.\n      console.log(chalk.dim(\"Using .swcrc from project root...\"));\n    } else {\n      // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.\n      console.log(chalk.dim(\"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  // API 프로젝트를 빌드합니다.\n  const apiStartedAt = Date.now();\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath: swcFilePath } });\n    }\n    printBuildSummary(\"API\", true, Date.now() - apiStartedAt);\n  } catch {\n    printBuildSummary(\"API\", false, Date.now() - apiStartedAt);\n    process.exit(1);\n  }\n\n  // Web 프로젝트를 빌드합니다.\n  const webStartedAt = Date.now();\n  try {\n    for (const artifact of WEB_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: {} });\n    }\n    printBuildSummary(\"Web\", true, Date.now() - webStartedAt);\n  } catch {\n    printBuildSummary(\"Web\", false, Date.now() - webStartedAt);\n    process.exit(1);\n  }\n}\n\n/**\n * pre-build, build, post-build 단계를 순차적으로 실행합니다.\n */\nasync function runBuildSteps<T>(\n  artifact: BuildArtifact<T>,\n  options: { cwd: string; buildCommandArgs: T },\n) {\n  const steps = [\n    { name: \"pre-build\", cmd: artifact.preBuildCommand?.() },\n    { name: \"build\", cmd: artifact.buildCommand(options.buildCommandArgs) },\n    { name: \"post-build\", cmd: artifact.postBuildCommand?.() },\n  ].filter((step) => step.cmd);\n\n  for (let i = 0; i < steps.length; i++) {\n    const step = steps[i];\n    const isLast = i === steps.length - 1;\n\n    try {\n      assert(step.cmd);\n      printTaskStart(step.name, step.cmd, isLast);\n      await execWithLinePrefix(step.cmd, { cwd: options.cwd });\n      printTaskSuccess(step.name, isLast);\n    } catch {\n      printTaskFailed(step.name, isLast);\n      throw new Error(`${step.name} failed`);\n    }\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,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture.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"],"names":["chalk","dotenv","config","assert","execSync","spawn","mkdir","readdir","writeFile","knex","createRequire","path","process","tsicli","Sonamu","EntityManager","Migrator","FixtureManager","execWithLinePrefix","printBuildSummary","printTaskFailed","printTaskHeader","printTaskStart","printTaskSuccess","exists","findApiRootPath","findAppRootPath","API_ARTIFACTS","WEB_ARTIFACTS","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","sync","dev","build","start","destroy","finally","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","appRoot","swcFilePath","dim","dirname","apiStartedAt","Date","now","artifact","projectPath","description","runBuildSteps","buildCommandArgs","configFilePath","webStartedAt","options","steps","cmd","preBuildCommand","buildCommand","postBuildCommand","filter","step","i","length","isLast","Error","blue","setupMigrator","setupFixtureManager","runAction","Object","keys","dbConfig","status","getStatus","srcConfig","development_master","targets","label","fixture","test","toSkip","remoteConn","connection","localConn","host","database","dumpFilename","srcConn","migrationsDump","user","password","_db","migrations","raw","count","conn","db","undefined","row","mysqlCmd","recordIds","importFixture","practiceDir","apiRootPath","fileNames","maxSeqNo","recursive","filteredSeqs","fileName","startsWith","endsWith","seqNo","match","parseInt","sort","a","b","currentSeqNo","dstPath","runCode","replace","createEntity","generateTemplate"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.7.34",
+  "version": "0.7.35",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -111,9 +111,9 @@
     "vitest": "^4.0.10",
     "exceljs": "^4.4.0",
     "zod": "^4.1.12",
-    "@sonamu-kit/hmr-hook": "^0.4.1",
     "@sonamu-kit/hmr-runner": "^0.1.1",
     "@sonamu-kit/tasks": "^0.1.3",
+    "@sonamu-kit/hmr-hook": "^0.4.1",
     "@sonamu-kit/ts-loader": "^2.1.3"
   },
   "devDependencies": {

package/src/bin/build-config.ts

@@ -1,43 +1,47 @@
+export type BuildArtifact<BuildCommandArgs = {}> = {
+  name: string;
+  description: string;
+  projectPath: string;
+  preBuildCommand?: () => string;
+  buildCommand: (args: BuildCommandArgs) => string;
+  postBuildCommand?: () => string;
+};
+
 /**
  * API 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
- *
- * 경로(projectPath, outputDir, destDir)는 app root에서 시작하는 상대경로로 작성되어 있습니다.
- * 다만 buildCommand는 projectPath를 기준으로 실행됩니다.
  */
-export const API_ARTIFACTS = [
+export const API_ARTIFACTS: BuildArtifact<{ configFilePath: string }>[] = [
   {
     name: "API",
     description: "API 프로젝트 빌드 산출물",
     projectPath: "api",
-    buildCommand: (configFilePath: string) =>
+    preBuildCommand: () => "rm -rf dist",
+    buildCommand: ({ configFilePath }) =>
       `tsc --noEmit && swc src -d dist --config-file ${configFilePath} --strip-leading-paths`,
-    outputDir: "api/dist",
   },
 ];
 
 /**
  * 웹 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
- *
- * 경로(projectPath, outputDir, destDir)는 app root에서 시작하는 상대경로로 작성되어 있습니다.
- * 다만 buildCommand는 projectPath를 기준(cwd)으로 실행됩니다.
  */
-export const WEB_ARTIFACTS = [
+export const WEB_ARTIFACTS: BuildArtifact[] = [
   {
     name: "Web Client",
     description: "Web 프로젝트 클라이언트 빌드 산출물",
     projectPath: "web",
-    buildCommand: () => "tsc && vite build --outDir dist/client",
-    outputDir: "web/dist/client",
-    destDir: "api/public/web",
+    preBuildCommand: () => "rm -rf dist/client && rm -rf ../api/public/web",
+    buildCommand: () => "tsc --noEmit && vite build --outDir dist/client",
+    postBuildCommand: () => "mkdir -p ../api/public/web && cp -r dist/client/* ../api/public/web",
   },
   {
     name: "Web Server",
     description: "Web 프로젝트 서버 빌드 산출물",
     projectPath: "web",
-    buildCommand: () => "vite build --ssr src/entry-server.generated.tsx --outDir dist/server",
-    outputDir: "web/dist/server",
-    destDir: "api/dist/ssr",
+    preBuildCommand: () => "rm -rf dist/server", // api/dist/ssr은 안 지웁니다! 거기는 api의 빌드 결과물이 들어있음!
+    buildCommand: () =>
+      "tsc --noEmit && vite build --ssr src/entry-server.generated.tsx --outDir dist/server",
+    postBuildCommand: () => "cp -r dist/server/* ../api/dist/ssr",
   },
 ];

package/src/bin/cli.ts

@@ -3,8 +3,9 @@ import dotenv from "dotenv";
 
 dotenv.config();
 
+import assert from "assert";
 import { execSync, spawn } from "child_process";
-import { cp, mkdir, readdir, rm, writeFile } from "fs/promises";
+import { mkdir, readdir, writeFile } from "fs/promises";
 import knex, { type Knex } from "knex";
 import { createRequire } from "module";
 import path from "path";
@@ -20,13 +21,12 @@ import {
   printBuildSummary,
   printTaskFailed,
   printTaskHeader,
-  printTaskSkipped,
   printTaskStart,
   printTaskSuccess,
 } from "../utils/console-util";
 import { exists } from "../utils/fs-utils";
 import { findApiRootPath, findAppRootPath } from "../utils/utils";
-import { API_ARTIFACTS, WEB_ARTIFACTS } from "./build-config";
+import { API_ARTIFACTS, type BuildArtifact, WEB_ARTIFACTS } from "./build-config";
 
 let migrator: Migrator;
 
@@ -192,32 +192,6 @@ async function dev() {
 async function build() {
   const appRoot = findAppRootPath();
 
-  // 출력 디렉토리를 제거합니다.
-  try {
-    for (const artifact of API_ARTIFACTS) {
-      if (await exists(path.join(appRoot, artifact.outputDir))) {
-        // API 프로젝트 자체의 빌드 결과물
-        await rm(path.join(appRoot, artifact.outputDir), { recursive: true, force: true });
-      }
-    }
-
-    for (const artifact of WEB_ARTIFACTS) {
-      if (await exists(path.join(appRoot, artifact.outputDir))) {
-        // Web 프로젝트 자체의 빌드 결과물
-        await rm(path.join(appRoot, artifact.outputDir), { recursive: true, force: true });
-      }
-      if (await exists(path.join(appRoot, artifact.destDir))) {
-        // API 프로젝트로 복사되어 온 Web 빌드 결과물
-        await rm(path.join(appRoot, artifact.destDir), { recursive: true, force: true });
-      }
-    }
-
-    console.log(chalk.green("\nBuild artifacts removed successfully."));
-  } catch (error) {
-    console.error(chalk.red("Remove build directories failed."), error);
-    process.exit(1);
-  }
-
   // .swcrc 파일을 지정합니다.
   let swcFilePath = ".swcrc";
   try {
@@ -239,20 +213,9 @@ async function build() {
   try {
     for (const artifact of API_ARTIFACTS) {
       const cwd = path.join(appRoot, artifact.projectPath);
-      const cmd = artifact.buildCommand(swcFilePath);
-
       printTaskHeader(artifact.name, artifact.description, cwd);
 
-      // build
-      try {
-        printTaskStart("build", cmd, true);
-        // cmd를 spawn해서 build를 수행하는데, 이때 명령의 출력(stdout, stderr) 라인 앞에 들여쓰기를 붙여서 출력합니다.
-        await execWithLinePrefix(cmd, { cwd });
-        printTaskSuccess("build", true);
-      } catch {
-        printTaskFailed("build", true);
-        throw new Error("build failed");
-      }
+      await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath: swcFilePath } });
     }
     printBuildSummary("API", true, Date.now() - apiStartedAt);
   } catch {
@@ -265,38 +228,9 @@ async function build() {
   try {
     for (const artifact of WEB_ARTIFACTS) {
       const cwd = path.join(appRoot, artifact.projectPath);
-      const cmd = artifact.buildCommand();
-      const outputDirFull = path.join(appRoot, artifact.outputDir);
-      const destDirFull = path.join(appRoot, artifact.destDir);
-
       printTaskHeader(artifact.name, artifact.description, cwd);
 
-      // build
-      try {
-        printTaskStart("build", cmd);
-        // cmd를 spawn해서 build를 수행하는데, 이때 명령의 출력(stdout, stderr) 라인 앞에 들여쓰기를 붙여서 출력합니다.
-        await execWithLinePrefix(cmd, { cwd });
-        printTaskSuccess("build");
-      } catch {
-        printTaskFailed("build");
-        printTaskSkipped("copy", true);
-        throw new Error("build failed");
-      }
-
-      // copy
-      try {
-        printTaskStart("copy", `${artifact.outputDir} → ${artifact.destDir}`, true);
-        // Web 아티팩트는 빌드 결과물(outputDir)을 다른 위치(destDir)로 복사하는 작업이 추가로 필요합니다.
-        if (await exists(destDirFull)) {
-          await rm(destDirFull, { recursive: true, force: true });
-        }
-        await mkdir(destDirFull, { recursive: true });
-        await cp(outputDirFull, destDirFull, { recursive: true });
-        printTaskSuccess("copy", true);
-      } catch {
-        printTaskFailed("copy", true);
-        throw new Error("copy failed");
-      }
+      await runBuildSteps(artifact, { cwd, buildCommandArgs: {} });
     }
     printBuildSummary("Web", true, Date.now() - webStartedAt);
   } catch {
@@ -305,6 +239,35 @@ async function build() {
   }
 }
 
+/**
+ * pre-build, build, post-build 단계를 순차적으로 실행합니다.
+ */
+async function runBuildSteps<T>(
+  artifact: BuildArtifact<T>,
+  options: { cwd: string; buildCommandArgs: T },
+) {
+  const steps = [
+    { name: "pre-build", cmd: artifact.preBuildCommand?.() },
+    { name: "build", cmd: artifact.buildCommand(options.buildCommandArgs) },
+    { name: "post-build", cmd: artifact.postBuildCommand?.() },
+  ].filter((step) => step.cmd);
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const isLast = i === steps.length - 1;
+
+    try {
+      assert(step.cmd);
+      printTaskStart(step.name, step.cmd, isLast);
+      await execWithLinePrefix(step.cmd, { cwd: options.cwd });
+      printTaskSuccess(step.name, isLast);
+    } catch {
+      printTaskFailed(step.name, isLast);
+      throw new Error(`${step.name} failed`);
+    }
+  }
+}
+
 /**
  * pnpm start 하면 실행되는 함수입니다.
  * 빌드된 프로젝트를 실행합니다.