@simplysm/sd-cli 13.0.70 → 13.0.72

package/templates/init/packages/db-main/src/tables/_DataLog.ts

@@ -0,0 +1,19 @@
+import { Table } from "@simplysm/orm-common";
+import { Employee } from "./Employee";
+
+export const _DataLog = Table("_DataLog")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    tableName: c.varchar(200),
+    tableDescription: c.varchar(200).nullable(),
+    action: c.varchar(50),
+    itemId: c.bigint().nullable(),
+    valueJson: c.text().nullable(),
+    dateTime: c.datetime(),
+    employeeId: c.bigint().nullable(),
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("tableName", "itemId"), i.index("dateTime").orderBy("DESC")])
+  .relations((r) => ({
+    employee: r.foreignKey(["employeeId"], () => Employee),
+  }));

package/templates/init/packages/db-main/src/tables/_Log.ts

@@ -0,0 +1,16 @@
+import { Table } from "@simplysm/orm-common";
+import { Employee } from "./Employee";
+
+export const _Log = Table("_Log")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    clientName: c.varchar(200),
+    dateTime: c.datetime(),
+    severity: c.varchar(50),
+    message: c.text(),
+    employeeId: c.bigint().nullable(),
+  }))
+  .primaryKey("id")
+  .relations((r) => ({
+    employee: r.foreignKey(["employeeId"], () => Employee),
+  }));

package/templates/init/packages/server/package.json.hbs

@@ -0,0 +1,20 @@
+{
+  "name": "@{{projectName}}/server",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "dependencies": {
+    "@{{projectName}}/db-main": "workspace:*",
+    "@simplysm/core-common": "~13.0.72",
+    "@simplysm/excel": "^13.0.71",
+    "@simplysm/orm-common": "~13.0.72",
+    "@simplysm/orm-node": "~13.0.72",
+    "@simplysm/service-server": "~13.0.72",
+    "bcrypt": "^6.0.0",
+    "pg": "^8.19.0",
+    "pg-copy-streams": "^7.0.0"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^6.0.0"
+  }
+}

package/templates/init/packages/server/src/index.ts

@@ -0,0 +1,4 @@
+export type { AuthServiceMethods } from "./services/AuthService";
+export type { IAuthResult, IAuthData } from "./services/AuthService";
+export type { DevServiceMethods } from "./services/DevService";
+export type { EmployeeServiceMethods } from "./services/EmployeeService";

package/templates/init/packages/server/src/main.ts.hbs

@@ -0,0 +1,34 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { env } from "@simplysm/core-common";
+import { createServiceServer, getConfig, OrmService } from "@simplysm/service-server";
+import { AuthService } from "./services/AuthService";
+import { DevService } from "./services/DevService";
+import { EmployeeService } from "./services/EmployeeService";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const config = await getConfig<Record<string, { jwtSecret: string }>>(
+  path.resolve(__dirname, ".config.json"),
+);
+
+if (config?.["auth"]?.jwtSecret == null || config["auth"].jwtSecret === "") {
+  throw new Error(
+    "Missing 'auth.jwtSecret' in .config.json. Server cannot start without JWT secret.",
+  );
+}
+
+export const server = createServiceServer({
+  rootPath: __dirname,
+  port: {{port}},
+  auth: config["auth"],
+  services: env.DEV
+    ? [OrmService, AuthService, DevService, EmployeeService]
+    : [OrmService, AuthService, EmployeeService],
+});
+
+// 프로덕션 모드: 정적 파일 서빙 포함하여 직접 listen
+// Watch 모드 (env.DEV): Server Runtime Worker가 proxy 설정 후 listen 호출
+if (!env.DEV) {
+  await server.listen();
+}

package/templates/init/packages/server/src/services/AuthService.ts.hbs

@@ -0,0 +1,171 @@
+import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
+import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
+import { expr } from "@simplysm/orm-common";
+import { MainDbContext, type MainDbContext as MainDbContextType } from "@{{projectName}}/db-main";
+import bcrypt from "bcrypt";
+
+export interface IAuthData {
+  employeeId: number;
+  employeeName: string;
+  email: string;
+  permissions: Record<string, boolean>;
+}
+
+export interface IAuthResult extends IAuthData {
+  token: string;
+}
+
+export const AuthService = defineService("AuthService", (ctx) => {
+  async function getOrm() {
+    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
+
+    return createOrm(MainDbContext, ormConfig.default);
+  }
+
+  async function getPermissions(
+    db: MainDbContextType,
+    roleId: number | undefined,
+  ): Promise<Record<string, boolean>> {
+    const permissions: Record<string, boolean> = {};
+
+    if (roleId != null) {
+      const rolePermissions = await db
+        .rolePermission()
+        .where((c) => [expr.eq(c.roleId, roleId)])
+        .result();
+
+      for (const rp of rolePermissions) {
+        permissions[rp.code] = JSON.parse(rp.valueJson);
+      }
+    }
+
+    return permissions;
+  }
+
+  async function buildAuthResult(
+    employee: { id: number; name: string; email: string | undefined },
+    permissions: Record<string, boolean>,
+  ): Promise<IAuthResult> {
+    const authData: IAuthData = {
+      employeeId: employee.id,
+      employeeName: employee.name,
+      email: employee.email ?? "",
+      permissions,
+    };
+
+    const token = await ctx.server.generateAuthToken({
+      roles: [],
+      data: authData,
+    });
+
+    return { token, ...authData };
+  }
+
+  function validateLoginInput(email: string, password: string): void {
+    if (email.length === 0 || email.length > 200) {
+      throw new Error("이메일은 1~200자의 문자열이어야 합니다.");
+    }
+    if (password.length === 0 || password.length > 500) {
+      throw new Error("비밀번호는 1~500자의 문자열이어야 합니다.");
+    }
+  }
+
+  return {
+    login: async (email: string, password: string): Promise<IAuthResult> => {
+      const orm = await getOrm();
+      validateLoginInput(email, password);
+
+      return orm.connect(async (db) => {
+        const employee = await db
+          .employee()
+          .where((c) => [expr.eq(c.email, email), expr.eq(c.isDeleted, false)])
+          .single();
+
+        if (!employee) {
+          throw new Error("이메일 또는 비밀번호가 올바르지 않습니다.");
+        }
+
+        if (employee.encryptedPassword == null || employee.encryptedPassword === "") {
+          throw new Error("비밀번호가 설정되지 않은 계정입니다.");
+        }
+
+        const isValid = await bcrypt.compare(password, employee.encryptedPassword);
+        if (!isValid) {
+          throw new Error("이메일 또는 비밀번호가 올바르지 않습니다.");
+        }
+
+        const permissions = await getPermissions(db, employee.roleId);
+
+        return buildAuthResult(employee, permissions);
+      });
+    },
+
+    refresh: auth(async (): Promise<IAuthResult> => {
+      const currentAuth = ctx.authInfo as IAuthData | undefined;
+      if (!currentAuth) {
+        throw new Error("인증 정보가 없습니다.");
+      }
+
+      const orm = await getOrm();
+
+      return orm.connect(async (db) => {
+        const employee = await db
+          .employee()
+          .where((c) => [expr.eq(c.id, currentAuth.employeeId), expr.eq(c.isDeleted, false)])
+          .single();
+
+        if (!employee) {
+          throw new Error("유효하지 않은 직원입니다.");
+        }
+
+        const permissions = await getPermissions(db, employee.roleId);
+
+        return buildAuthResult(employee, permissions);
+      });
+    }),
+
+    changePassword: auth(async (currentPassword: string, newPassword: string): Promise<void> => {
+      const currentAuth = ctx.authInfo as IAuthData | undefined;
+      if (!currentAuth) {
+        throw new Error("인증 정보가 없습니다.");
+      }
+
+      validateLoginInput(currentAuth.email, currentPassword);
+      validateLoginInput(currentAuth.email, newPassword);
+
+      if (newPassword.length < 8) {
+        throw new Error("새 비밀번호는 최소 8자 이상이어야 합니다.");
+      }
+
+      const orm = await getOrm();
+
+      await orm.connect(async (db) => {
+        const employee = await db
+          .employee()
+          .where((c) => [expr.eq(c.id, currentAuth.employeeId), expr.eq(c.isDeleted, false)])
+          .single();
+
+        if (!employee) {
+          throw new Error("유효하지 않은 직원입니다.");
+        }
+
+        if (employee.encryptedPassword == null || employee.encryptedPassword === "") {
+          throw new Error("비밀번호가 설정되지 않은 계정입니다.");
+        }
+
+        const isCurrentValid = await bcrypt.compare(currentPassword, employee.encryptedPassword);
+        if (!isCurrentValid) {
+          throw new Error("현재 비밀번호가 올바르지 않습니다.");
+        }
+
+        const encryptedPassword = await bcrypt.hash(newPassword, 10);
+        await db
+          .employee()
+          .where((c) => [expr.eq(c.id, employee.id)])
+          .update(() => ({ encryptedPassword: expr.val("string", encryptedPassword) }));
+      });
+    }),
+  };
+});
+
+export type AuthServiceMethods = ServiceMethods<typeof AuthService>;

package/templates/init/packages/server/src/services/DevService.ts.hbs

@@ -0,0 +1,94 @@
+import { defineService, type ServiceMethods } from "@simplysm/service-server";
+import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
+import { MainDbContext } from "@{{projectName}}/db-main";
+import { ExcelWorkbook } from "@simplysm/excel";
+import bcrypt from "bcrypt";
+import fs from "fs";
+import path from "path";
+
+export const DevService = defineService("DevService", (ctx) => {
+  async function getOrm() {
+    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
+    return createOrm(MainDbContext, ormConfig.default);
+  }
+
+  return {
+    initDb: async (permCodes: string[]) => {
+      const orm = await getOrm();
+
+      await orm.connectWithoutTransaction(async (db) => {
+        await db.initialize({ force: true });
+
+        const excelPath = path.resolve(ctx.server.options.rootPath, "dev/초기화.xlsx");
+        if (!fs.existsSync(excelPath)) {
+          throw new Error(`초기화 파일을 찾을 수 없습니다: ${excelPath}`);
+        }
+
+        const buffer = fs.readFileSync(excelPath);
+        const wb = new ExcelWorkbook(buffer);
+        const wsNames = await wb.getWorksheetNames();
+
+        // Role
+        if (wsNames.includes("권한그룹")) {
+          const ws = await wb.getWorksheet("권한그룹");
+          const rows = await ws.getDataTable();
+          const filtered = rows.filter((r: Record<string, any>) => r["ID"] != null);
+          if (filtered.length > 0) {
+            await db.role().insert(
+              filtered.map((r: Record<string, any>) => ({
+                id: Number(r["ID"]),
+                name: String(r["명칭"]),
+              })),
+            );
+          }
+        }
+
+        // RolePermission
+        if (wsNames.includes("권한그룹권한")) {
+          const ws = await wb.getWorksheet("권한그룹권한");
+          const rows = await ws.getDataTable();
+          const filtered = rows.filter((r: Record<string, any>) => r["권한그룹.ID"] != null);
+          if (filtered.length > 0) {
+            const permRows = filtered.flatMap((r: Record<string, any>) => {
+              const roleId = Number(r["권한그룹.ID"]);
+              const code = String(r["코드"]);
+              const valueJson = String(r["값"]);
+
+              if (code === "ALL") {
+                return permCodes.map((pc) => ({ roleId, code: pc, valueJson }));
+              }
+              return [{ roleId, code, valueJson }];
+            });
+
+            await db.rolePermission().insert(permRows);
+          }
+        }
+
+        // Employee (bcrypt hash passwords)
+        if (wsNames.includes("직원")) {
+          const ws = await wb.getWorksheet("직원");
+          const rows = await ws.getDataTable();
+          const filtered = rows.filter((r: Record<string, any>) => r["ID"] != null);
+          if (filtered.length > 0) {
+            const employees = [];
+            for (const r of filtered) {
+              const pw = r["비밀번호"];
+              employees.push({
+                id: Number(r["ID"]),
+                name: String(r["이름"]),
+                email: r["이메일"] != null ? String(r["이메일"]) : undefined,
+                encryptedPassword:
+                  pw != null && String(pw) !== "" ? await bcrypt.hash(String(pw), 10) : undefined,
+                roleId: r["권한그룹.ID"] != null ? Number(r["권한그룹.ID"]) : undefined,
+                isDeleted: Boolean(r["삭제"]),
+              });
+            }
+            await db.employee().insert(employees);
+          }
+        }
+      });
+    },
+  };
+});
+
+export type DevServiceMethods = ServiceMethods<typeof DevService>;

package/templates/init/packages/server/src/services/EmployeeService.ts.hbs

@@ -0,0 +1,122 @@
+import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
+import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
+import { expr } from "@simplysm/orm-common";
+import { MainDbContext } from "@{{projectName}}/db-main";
+import { DateOnly, strIsNullOrEmpty } from "@simplysm/core-common";
+import bcrypt from "bcrypt";
+import type { IAuthData } from "./AuthService";
+
+export const EmployeeService = defineService("EmployeeService", (ctx) => {
+  async function getOrm() {
+    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
+    return createOrm(MainDbContext, ormConfig.default);
+  }
+
+  return {
+    save: auth(
+      async (
+        items: {
+          id?: number;
+          name?: string;
+          email?: string;
+          phoneNumber?: string;
+          birthDate?: DateOnly;
+          enteringDate?: DateOnly;
+          leavingDate?: DateOnly;
+          socialSecurityNumber?: string;
+          payrollAccountBank?: string;
+          payrollAccountNumber?: string;
+          password?: string;
+          isDeleted: boolean;
+        }[],
+      ): Promise<number[]> => {
+        const authData = ctx.authInfo as IAuthData | undefined;
+        if (authData?.permissions["/home/base/employee/edit"] !== true) {
+          throw new Error("저장 권한이 없습니다.");
+        }
+
+        const ids: number[] = [];
+        const orm = await getOrm();
+        await orm.connect(async (db) => {
+          for (const item of items) {
+            if (
+              !item.isDeleted &&
+              !strIsNullOrEmpty(item.name) &&
+              (await db
+                .employee()
+                .where((c) => [
+                  expr.not(expr.eq(c.id, item.id)),
+                  expr.eq(c.isDeleted, false),
+                  expr.eq(c.name, item.name),
+                ])
+                .exists())
+            ) {
+              throw new Error(`동일한 이름이 이미 등록되어 있습니다: ${item.name}`);
+            }
+
+            if (
+              !item.isDeleted &&
+              !strIsNullOrEmpty(item.email) &&
+              (await db
+                .employee()
+                .where((c) => [
+                  expr.not(expr.eq(c.id, item.id)),
+                  expr.eq(c.isDeleted, false),
+                  expr.eq(c.email, item.email),
+                ])
+                .exists())
+            ) {
+              throw new Error(`동일한 이메일이 이미 등록되어 있습니다: ${item.email}`);
+            }
+
+            const passwordObj =
+              authData.permissions["/home/base/employee/auth/edit"] &&
+              !strIsNullOrEmpty(item.password)
+                ? { encryptedPassword: await bcrypt.hash(item.password, 10) }
+                : {};
+
+            const upsertedId = (
+              await db
+                .employee()
+                .where((c) => [expr.eq(c.id, item.id)])
+                .upsert(
+                  () => ({
+                    name: item.name,
+                    email: item.email,
+                    phoneNumber: item.phoneNumber,
+                    birthDate: item.birthDate,
+                    enteringDate: item.enteringDate,
+                    leavingDate: item.leavingDate,
+                    isDeleted: item.isDeleted,
+                    ...(authData.permissions["/home/base/employee/personal/edit"]
+                      ? { socialSecurityNumber: item.socialSecurityNumber }
+                      : {}),
+                    ...(authData.permissions["/home/base/employee/payroll/edit"]
+                      ? {
+                          payrollAccountBank: item.payrollAccountBank,
+                          payrollAccountNumber: item.payrollAccountNumber,
+                        }
+                      : {}),
+                    ...passwordObj,
+                  }),
+                  ["id"],
+                )
+            ).single()?.id;
+
+            if (upsertedId != null) {
+              ids.push(upsertedId);
+              await db.employee().insertDataLog({
+                action: item.id == null ? "등록" : "수정",
+                itemId: upsertedId,
+                employeeId: authData.employeeId,
+              });
+            }
+          }
+        });
+        return ids;
+      },
+    ),
+  };
+});
+
+export type EmployeeServiceMethods = ServiceMethods<typeof EmployeeService>;

package/templates/init/packages/server/src/services/RoleService.ts.hbs

@@ -0,0 +1,59 @@
+import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
+import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
+import { expr } from "@simplysm/orm-common";
+import { MainDbContext } from "@{{projectName}}/db-main";
+import { strIsNullOrEmpty } from "@simplysm/core-common";
+import type { IAuthData } from "./AuthService";
+
+export const RoleService = defineService("RoleService", (ctx) => {
+  async function getOrm() {
+    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
+    return createOrm(MainDbContext, ormConfig.default);
+  }
+
+  return {
+    save: auth(
+      async (
+        items: {
+          id?: number;
+          name?: string;
+        }[],
+      ): Promise<void> => {
+        const authData = ctx.authInfo as IAuthData | undefined;
+        if (authData?.permissions["/home/base/role-permission/edit"] !== true) {
+          throw new Error("저장 권한이 없습니다.");
+        }
+
+        const orm = await getOrm();
+        await orm.connect(async (db) => {
+          for (const item of items) {
+            if (
+              !strIsNullOrEmpty(item.name) &&
+              (await db
+                .role()
+                .where((c) => [
+                  expr.not(expr.eq(c.id, item.id)),
+                  expr.eq(c.name, item.name),
+                ])
+                .exists())
+            ) {
+              throw new Error(`이미 존재하는 권한그룹 이름입니다: ${item.name}`);
+            }
+
+            await db
+              .role()
+              .where((c) => [expr.eq(c.id, item.id)])
+              .upsert(
+                () => ({
+                  name: item.name ?? "",
+                }),
+                ["id"],
+              );
+          }
+        });
+      },
+    ),
+  };
+});
+
+export type RoleServiceMethods = ServiceMethods<typeof RoleService>;

package/templates/init/{pnpm-workspace.yaml.hbs → pnpm-workspace.yaml}

@@ -3,11 +3,13 @@ packages:
   - tests/*
 
 onlyBuiltDependencies:
-  - '@simplysm/sd-claude'
+  - "@simplysm/sd-claude"
+  - bcrypt
   - bufferutil
   - core-js
   - cpu-features
   - esbuild
   - sharp
   - ssh2
+  - unrs-resolver
   - utf-8-validate

package/templates/init/sd.config.ts.hbs

@@ -1,7 +1,36 @@
 import type { SdConfigFn } from "@simplysm/sd-cli";
 
+const dbPort = Number(process.env["DB_PORT"] ?? 5432);
+const dbDatabase = process.env["DB_DATABASE"] ?? "{{projectName}}";
+
 const config: SdConfigFn = () => ({
-  packages: {},
+  packages: {
+    "db-main": { target: "neutral" },
+    "client-admin": {
+      target: "client",
+      server: "server",
+    },
+    "server": {
+      target: "server",
+      packageManager: "volta",
+      pm2: {},
+      configs: {
+        orm: {
+          default: {
+            dialect: "postgresql",
+            host: "localhost",
+            port: dbPort,
+            username: "postgres",
+            password: "1234",
+            database: dbDatabase,
+          },
+        },
+        auth: {
+          jwtSecret: "{{jwtSecret}}",
+        },
+      },
+    },
+  },
 });
 
 export default config;

package/templates/init/tests/e2e/package.json.hbs

@@ -0,0 +1,16 @@
+{
+  "name": "@{{projectName}}-test/e2e",
+  "version": "1.0.0",
+  "description": "{{projectName}} E2E tests",
+  "type": "module",
+  "private": true,
+  "dependencies": {
+    "@{{projectName}}/db-main": "workspace:*",
+    "@simplysm/orm-node": "~13.0.72",
+    "bcrypt": "^6.0.0",
+    "playwright": "^1.58.2"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^6.0.0"
+  }
+}

package/templates/init/tests/e2e/src/e2e.spec.ts

@@ -0,0 +1,36 @@
+import { describe, inject, beforeAll, afterAll } from "vitest";
+import { chromium, type Browser, type BrowserContext, type Page } from "playwright";
+import { loginTests } from "./login";
+import { employeeCrudTests } from "./employee-crud";
+
+const ctx = {} as { page: Page; baseUrl: string };
+
+let browser: Browser;
+let context: BrowserContext;
+
+describe("E2E", () => {
+  beforeAll(async () => {
+    ctx.baseUrl = inject("baseUrl");
+    browser = await chromium.launch({ headless: true });
+    context = await browser.newContext();
+    ctx.page = await context.newPage();
+    ctx.page.setDefaultTimeout(500);
+
+    // 브라우저 콘솔 에러 → 테스트 콘솔에 출력
+    ctx.page.on("pageerror", (err) => {
+      console.error(`[PAGE_ERROR] ${err.message}`);
+    });
+    ctx.page.on("console", (msg) => {
+      if (msg.type() === "error") {
+        console.error(`[CONSOLE_ERROR] ${msg.text()}`);
+      }
+    });
+  });
+
+  afterAll(async () => {
+    await browser.close();
+  });
+
+  loginTests(ctx);
+  employeeCrudTests(ctx);
+});