@simplysm/sd-cli 14.0.89 → 14.0.90

package/src/commands/init/templates/server/src/services/dev.service.ts.hbs

@@ -0,0 +1,112 @@
+{{#if hasAuth}}
+import path from "node:path";
+{{/if}}
+import { defineService, type ServiceMethods } from "@simplysm/service-server";
+{{#if hasAuth}}
+import { getFlatPermissions } from "@simplysm/service-common";
+import { ExcelWorkbook } from "@simplysm/excel";
+import bcrypt from "bcrypt";
+import { fsx } from "@simplysm/core-node";
+{{/if}}
+import { getOrm } from "../utils/orm.utils";
+{{#if hasAuth}}
+import { {{#each appStructureNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}} } from "@{{workspaceName}}/common";
+{{/if}}
+
+export const DevService = defineService("DevService", (ctx) => {
+{{#if hasAuth}}
+  async function loadInitXlsx() {
+    const excelPath = path.resolve(ctx.server.options.rootPath, "초기화.xlsx");
+    if (!(await fsx.exists(excelPath))) {
+      throw new Error(`초기화 파일을 찾을 수 없습니다: ${excelPath}`);
+    }
+
+    const xlsxBytes = await fsx.readBytes(excelPath);
+    const wb = new ExcelWorkbook(xlsxBytes);
+    const excelData: Record<string, Record<string, any>[]> = {};
+    try {
+      for (const wsName of await wb.getWorksheetNames()) {
+        const ws = await wb.getWorksheet(wsName);
+        excelData[wsName] = await ws.getDataTable();
+      }
+    } finally {
+      await wb.close();
+    }
+
+    return excelData;
+  }
+{{/if}}
+
+  return {
+    initDb: async (): Promise<void> => {
+{{#if hasAuth}}
+      const excelData = await loadInitXlsx();
+
+{{/if}}
+      const orm = await getOrm(ctx);
+      await orm.connectWithoutTransaction(async (db) => {
+        await db.initialize({ force: true });
+
+{{#if hasAuth}}
+        await db.transaction(async () => {
+          if ("역할" in excelData) {
+            await db
+              .role()
+              .insert(
+                excelData["역할"]
+                  .filter((r) => r["ID"] != null)
+                  .map((r) => ({ id: r["ID"], name: r["명칭"], isDeleted: false })),
+              );
+            await db.role().insertDataLog({ action: "초기화" });
+          }
+
+          if ("직원" in excelData) {
+            await db.{{userEntityCamel}}().insert(
+              await excelData["직원"]
+                .filter((r) => r["ID"] != null)
+                .mapAsync(async (r) => ({
+                  id: r["ID"],
+                  name: r["이름"],
+                  loginId: r["로그인ID"],
+                  encryptedPassword: await bcrypt.hash(r["비밀번호"], 10),
+                  roleId: r["역할.ID"],
+                  isDeleted: false,
+                })),
+            );
+            await db.{{userEntityCamel}}().insertDataLog({ action: "초기화" });
+          }
+
+          if ("역할권한" in excelData) {
+            const allPermCodes = getFlatPermissions(
+              [{{#each appStructureNames}}...{{this}}{{#unless @last}}, {{/unless}}{{/each}}],
+              undefined,
+            )
+              .map((p) => p.codeChain.join("."))
+              .distinct();
+            await db.rolePermission().insert(
+              excelData["역할권한"]
+                .filter((r) => r["역할.ID"] != null)
+                .flatMap((r) =>
+                  r["코드"] === "ALL"
+                    ? allPermCodes.map((code) => ({
+                        roleId: r["역할.ID"],
+                        code,
+                        valueJson: r["값"],
+                      }))
+                    : [{ roleId: r["역할.ID"], code: r["코드"], valueJson: r["값"] }],
+                ),
+            );
+            await db.rolePermission().insertDataLog({ action: "초기화" });
+          }
+
+          // TODO: 업무 테이블 초기 데이터 시드 추가
+        });
+{{else}}
+        // TODO: 초기 데이터 시드 추가
+{{/if}}
+      });
+    },
+  };
+});
+
+export type DevServiceMethods = ServiceMethods<typeof DevService>;

package/src/commands/init/templates/server/src/utils/orm.utils.ts.hbs

@@ -0,0 +1,8 @@
+import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
+import { {{dbContextClassName}} } from "@{{workspaceName}}/common";
+import type { ServiceContext } from "@simplysm/service-server";
+
+export async function getOrm(ctx: ServiceContext) {
+  const ormConfig = await ctx.getConfig<{ {{dbContextNameUpper}}: DbConnConfig }>("orm");
+  return createOrm({{dbContextClassName}}, ormConfig.{{dbContextNameUpper}});
+}

package/src/commands/init/templates/workspace-root/sd.config.ts.hbs

@@ -15,8 +15,8 @@ const config: SdConfigFn = () => ({
             dialect: "{{dbDialect}}",
             host: "localhost",
             port: {{dbPort}},
-            username: "root",
-            password: "1234",
+            username: "{{dbUsername}}",
+            password: "{{dbPassword}}",
             database: "{{workspaceNameUpper}}",
             defaultIsolationLevel: "READ_UNCOMMITTED",
           },

package/src/commands/init/types.ts

@@ -1,5 +1,5 @@
 export type ClientType = "web" | "mobile";
-export type DbDialect = "mysql" | "postgres" | "mssql";
+export type DbDialect = "mysql" | "postgresql" | "mssql";
 
 export interface ClientInputSpec {
   name: string;
@@ -15,6 +15,9 @@ export interface InitInput {
   hasDb: boolean;
   dbDialect?: DbDialect;
   dbContextName?: string;
+  hasAuth?: boolean;
+  userEntityName?: string;
+  userEntityLabel?: string;
   mobileAppId?: string;
   serverPort?: number;
 }
@@ -24,6 +27,8 @@ export interface ClientSpec {
   type: ClientType;
   hasRouter: boolean;
   isMobile: boolean;
+  appStructureName: string;
+  needsNgIcons: boolean;
 }
 
 export interface NormalizedInput {
@@ -34,11 +39,21 @@ export interface NormalizedInput {
   hasDb: boolean;
   dbDialect?: DbDialect;
   dbPort: number;
+  dbUsername: string;
+  dbPassword: string;
   isMysql: boolean;
   isPostgres: boolean;
   isMssql: boolean;
   dbContextClassName: string;
   dbContextNameUpper: string;
+  dbContextFileName: string;
+  dbFolderName: string;
+  hasAuth: boolean;
+  userEntityPascal: string;
+  userEntityCamel: string;
+  userEntityKebab: string;
+  userEntityLabel: string;
+  appStructureNames: string[];
   serverPort: number;
   mobileAppId?: string;
   firstMobileClientName?: string;

package/src/commands/init/validate.ts

@@ -26,6 +26,12 @@ export function validateInput(input: InitInput): void {
     );
   }
 
+  if (input.hasAuth && input.userEntityName != null && !KEBAB_CASE_RE.test(input.userEntityName)) {
+    throw new Error(
+      `사용자 엔티티 영문 식별자는 kebab-case 여야 합니다 (예: employee). 입력값: "${input.userEntityName}"`,
+    );
+  }
+
   const clientNames = new Set<string>();
   for (const c of input.clients) {
     if (!KEBAB_CASE_RE.test(c.name)) {

package/tests/init/__snapshots__/render.spec.ts.snap

@@ -1,50 +1,68 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`client/src/main.ts.hbs > 라우팅 N (mobile) 1`] = `
-"import { enableProdMode } from "@angular/core";
+"import consola from "consola";
+import { enableProdMode, inject, provideAppInitializer } from "@angular/core";
 import { bootstrapApplication } from "@angular/platform-browser";
 import { provideHttpClient, withFetch } from "@angular/common/http";
 import { provideSdAngular } from "@simplysm/angular";
-import { AppPage } from "./AppPage";
+import { AppServiceProvider } from "@demo/client-common";
+import { AppRoot } from "./app.root";
 import "./styles.scss";
 
 if (typeof ngDevMode !== "undefined" && !ngDevMode) {
   enableProdMode();
+} else {
+  consola.log("dev mode");
 }
 
-bootstrapApplication(AppPage, {
+bootstrapApplication(AppRoot, {
   providers: [
     provideHttpClient(withFetch()),
     provideSdAngular({ clientName: "client-pda" }),
+
+    //-- app-service 연결
+    provideAppInitializer(async () => {
+      await inject(AppServiceProvider).connectAsync();
+    }),
   ],
 }).catch((err: unknown) => {
-  console.error(err);
+  consola.error(err);
 });
 "
 `;
 
 exports[`client/src/main.ts.hbs > 라우팅 Y (web) 1`] = `
-"import { enableProdMode } from "@angular/core";
+"import consola from "consola";
+import { enableProdMode, inject, provideAppInitializer } from "@angular/core";
 import { bootstrapApplication } from "@angular/platform-browser";
 import { provideHttpClient, withFetch } from "@angular/common/http";
 import { provideRouter, withHashLocation } from "@angular/router";
 import { provideSdAngular } from "@simplysm/angular";
-import { AppPage } from "./AppPage";
+import { AppServiceProvider } from "@demo/client-common";
+import { AppRoot } from "./app.root";
 import { routes } from "./routes";
 import "./styles.scss";
 
 if (typeof ngDevMode !== "undefined" && !ngDevMode) {
   enableProdMode();
+} else {
+  consola.log("dev mode");
 }
 
-bootstrapApplication(AppPage, {
+bootstrapApplication(AppRoot, {
   providers: [
     provideHttpClient(withFetch()),
     provideRouter(routes, withHashLocation()),
     provideSdAngular({ clientName: "client-admin" }),
+
+    //-- app-service 연결
+    provideAppInitializer(async () => {
+      await inject(AppServiceProvider).connectAsync();
+    }),
   ],
 }).catch((err: unknown) => {
-  console.error(err);
+  consola.error(err);
 });
 "
 `;
@@ -159,6 +177,10 @@ exports[`server/src/main.ts.hbs > DB=N — OrmService 없음 1`] = `
 import { env, num, parseBoolEnv } from "@simplysm/core-common";
 import { setupConsola } from "@simplysm/core-node";
 import { createServiceServer, getConfig } from "@simplysm/service-server";
+import {EventEmitter} from "node:events";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
 
 setupConsola();
 
@@ -188,6 +210,11 @@ exports[`server/src/main.ts.hbs > DB=Y — OrmService 포함 1`] = `
 import { env, num, parseBoolEnv } from "@simplysm/core-common";
 import { setupConsola } from "@simplysm/core-node";
 import { createServiceServer, getConfig, OrmService } from "@simplysm/service-server";
+import {EventEmitter} from "node:events";
+import { DevService } from "./services/dev.service";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
 
 setupConsola();
 
@@ -201,7 +228,7 @@ if (authConfig?.jwtSecret == null) {
 
 export const server = createServiceServer({
   rootPath: import.meta.dirname,
-  services: [OrmService],
+  services: [OrmService, ...(parseBoolEnv(env("DEV")) ? [DevService] : [])],
   port: num.parseInt(env("SERVER_PORT"))!,
   auth: { jwtSecret: authConfig.jwtSecret },
 });

package/tests/init/normalize.spec.ts

@@ -76,7 +76,7 @@ describe("normalize", () => {
       normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mysql" }).dbPort,
     ).toBe(3306);
     expect(
-      normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "postgres" }).dbPort,
+      normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "postgresql" }).dbPort,
     ).toBe(5432);
     expect(
       normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mssql" }).dbPort,
@@ -143,6 +143,26 @@ describe("normalize", () => {
     expect(normalize(base).dbContextClassName).toBe("");
   });
 
+  it("DB=Y default → dbContextFileName=main.db-context", () => {
+    const r = normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mysql" });
+    expect(r.dbContextFileName).toBe("main.db-context");
+  });
+
+  it("DB=Y dbContextName=userOrder → dbContextFileName=user-order.db-context", () => {
+    const r = normalize({
+      ...base,
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "mysql",
+      dbContextName: "userOrder",
+    });
+    expect(r.dbContextFileName).toBe("user-order.db-context");
+  });
+
+  it("DB=N 시 dbContextFileName 은 빈 문자열", () => {
+    expect(normalize(base).dbContextFileName).toBe("");
+  });
+
   it("DB=Y default → dbContextNameUpper=MAIN", () => {
     const r = normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mysql" });
     expect(r.dbContextNameUpper).toBe("MAIN");
@@ -169,4 +189,78 @@ describe("normalize", () => {
     });
     expect(r.dbContextNameUpper).toBe("MAIN");
   });
+
+  it("DB=Y default → dbFolderName=db-main", () => {
+    const r = normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mysql" });
+    expect(r.dbFolderName).toBe("db-main");
+  });
+
+  it("DB=Y dbContextName=userOrder → dbFolderName=db-user-order", () => {
+    const r = normalize({
+      ...base,
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "mysql",
+      dbContextName: "userOrder",
+    });
+    expect(r.dbFolderName).toBe("db-user-order");
+  });
+
+  it("DB=N 시 dbFolderName 은 빈 문자열", () => {
+    expect(normalize(base).dbFolderName).toBe("");
+  });
+
+  it("DB=N 이면 hasAuth=Y 입력해도 강제 false", () => {
+    const r = normalize({ ...base, hasServer: true, hasDb: false, hasAuth: true });
+    expect(r.hasAuth).toBe(false);
+  });
+
+  it("DB=Y + hasAuth 미입력 → hasAuth=false", () => {
+    const r = normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mysql" });
+    expect(r.hasAuth).toBe(false);
+    expect(r.userEntityPascal).toBe("");
+    expect(r.userEntityCamel).toBe("");
+    expect(r.userEntityKebab).toBe("");
+    expect(r.userEntityLabel).toBe("");
+  });
+
+  it("hasAuth=Y default → user/사용자 파생", () => {
+    const r = normalize({ ...base, hasServer: true, hasDb: true, dbDialect: "mysql", hasAuth: true });
+    expect(r.hasAuth).toBe(true);
+    expect(r.userEntityPascal).toBe("User");
+    expect(r.userEntityCamel).toBe("user");
+    expect(r.userEntityKebab).toBe("user");
+    expect(r.userEntityLabel).toBe("사용자");
+  });
+
+  it("hasAuth=Y + userEntityName=employee/직원 → Employee/employee 파생", () => {
+    const r = normalize({
+      ...base,
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "mysql",
+      hasAuth: true,
+      userEntityName: "employee",
+      userEntityLabel: "직원",
+    });
+    expect(r.userEntityPascal).toBe("Employee");
+    expect(r.userEntityCamel).toBe("employee");
+    expect(r.userEntityKebab).toBe("employee");
+    expect(r.userEntityLabel).toBe("직원");
+  });
+
+  it("hasAuth=Y + 복합어 userEntityName=staff-member → StaffMember/staffMember 파생", () => {
+    const r = normalize({
+      ...base,
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "mysql",
+      hasAuth: true,
+      userEntityName: "staff-member",
+      userEntityLabel: "직원",
+    });
+    expect(r.userEntityPascal).toBe("StaffMember");
+    expect(r.userEntityCamel).toBe("staffMember");
+    expect(r.userEntityKebab).toBe("staff-member");
+  });
 });