@simplysm/sd-cli 14.0.89 → 14.0.90

package/src/commands/init/templates/common/src/db/system-data-log.ext.ts.hbs

@@ -0,0 +1,138 @@
+import { DateTime } from "@simplysm/core-common";
+import { type DataRecord, expr, Queryable, queryable, type TableBuilder } from "@simplysm/orm-common";
+import { SystemDataLog } from "./tables/system/system-data-log";
+
+// ── Type Declarations ──
+
+export type IDataLogJoinOptions = {
+  includeActions?: string[];
+  excludeActions?: string[];
+};
+
+export type IDataLogJoinResult = {
+  action?: string;
+  dateTime?: DateTime;
+{{#if hasAuth}}
+  {{userEntityCamel}}Id?: number;
+  {{userEntityCamel}}Name?: string;
+{{/if}}
+};
+
+export type IInsertDataLogParam = {
+  action: string;
+  itemId?: number;
+  valueJson?: string;
+{{#if hasAuth}}
+  {{userEntityCamel}}Id?: number;
+{{/if}}
+};
+
+declare module "@simplysm/orm-common" {
+  interface Queryable<TData extends DataRecord, TFrom extends TableBuilder<any, any, any> | never> {
+    joinLastDataLog(
+      opts?: IDataLogJoinOptions,
+    ): Queryable<TData & { lastDataLog?: IDataLogJoinResult }, TFrom>;
+
+    joinFirstDataLog(
+      opts?: IDataLogJoinOptions,
+    ): Queryable<TData & { firstDataLog?: IDataLogJoinResult }, TFrom>;
+
+    insertDataLog(log: IInsertDataLogParam): Promise<void>;
+  }
+}
+
+// ── Runtime: insertDataLog ──
+
+Queryable.prototype.insertDataLog = async function (
+  this: Queryable<any, any>,
+  log: IInsertDataLogParam,
+): Promise<void> {
+  const fromTable = this.meta.from as TableBuilder<any, any, any>;
+  const qr = queryable(this.meta.db, SystemDataLog);
+
+  await qr().insert([
+    {
+      tableName: fromTable.meta.name,
+      tableDescription: fromTable.meta.description,
+      action: log.action,
+      itemId: log.itemId,
+      valueJson: log.valueJson,
+      dateTime: new DateTime(),
+{{#if hasAuth}}
+      {{userEntityCamel}}Id: log.{{userEntityCamel}}Id,
+{{/if}}
+    },
+  ]);
+};
+
+// ── Runtime: joinLastDataLog ──
+
+Queryable.prototype.joinLastDataLog = function (
+  this: Queryable<any, any>,
+  opts?: IDataLogJoinOptions,
+) {
+  const tableName = (this.meta.from as TableBuilder<any, any, any>).meta.name;
+
+  return this.joinSingle("lastDataLog", (qr, en) =>
+    qr
+      .from(SystemDataLog)
+      .where((dl) => [
+        expr.eq(dl.tableName, tableName),
+        expr.eq(dl.itemId, en["id"]),
+        ...(opts?.includeActions ? [expr.in(dl.action, opts.includeActions)] : []),
+        ...(opts?.excludeActions ? [expr.not(expr.in(dl.action, opts.excludeActions))] : []),
+      ])
+      .orderBy((dl) => dl.dateTime, "DESC")
+      .top(1)
+{{#if hasAuth}}
+      .include((dl) => dl.{{userEntityCamel}})
+      .select((dl) => ({
+        action: dl.action,
+        dateTime: dl.dateTime,
+        {{userEntityCamel}}Id: dl.{{userEntityCamel}}Id,
+        {{userEntityCamel}}Name: dl.{{userEntityCamel}}!.name,
+      })),
+{{else}}
+      .select((dl) => ({
+        action: dl.action,
+        dateTime: dl.dateTime,
+      })),
+{{/if}}
+  );
+};
+
+// ── Runtime: joinFirstDataLog ──
+
+Queryable.prototype.joinFirstDataLog = function (
+  this: Queryable<any, any>,
+  opts?: IDataLogJoinOptions,
+) {
+  const tableName = (this.meta.from as TableBuilder<any, any, any>).meta.name;
+
+  return this.joinSingle("firstDataLog", (qr, en) =>
+    qr
+      .from(SystemDataLog)
+      .where((dl) => [
+        expr.eq(dl.tableName, tableName),
+        expr.eq(dl.itemId, en["id"]),
+        ...(opts?.includeActions ? [expr.in(dl.action, opts.includeActions)] : []),
+        ...(opts?.excludeActions ? [expr.not(expr.in(dl.action, opts.excludeActions))] : []),
+      ])
+      .orderBy((dl) => dl.dateTime, "ASC")
+      .top(1)
+{{#if hasAuth}}
+      .include((dl) => dl.{{userEntityCamel}})
+      .select((dl) => ({
+        action: dl.action,
+        dateTime: dl.dateTime,
+        {{userEntityCamel}}Id: dl.{{userEntityCamel}}Id,
+        {{userEntityCamel}}Name: dl.{{userEntityCamel}}!.name,
+      })),
+{{else}}
+      .select((dl) => ({
+        action: dl.action,
+        dateTime: dl.dateTime,
+      })),
+{{/if}}
+  );
+};

package/src/commands/init/templates/common/src/db/tables/master/user-config.ts.hbs

@@ -0,0 +1,15 @@
+import { Table } from "@simplysm/orm-common";
+import { {{userEntityPascal}} } from "./{{userEntityKebab}}";
+
+export const {{userEntityPascal}}Config = Table("{{userEntityPascal}}Config")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    {{userEntityCamel}}Id: c.bigint(),
+    code: c.varchar(200),
+    valueJson: c.text(),
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("{{userEntityCamel}}Id", "code").unique()])
+  .relations((r) => ({
+    {{userEntityCamel}}: r.foreignKey(["{{userEntityCamel}}Id"], () => {{userEntityPascal}}),
+  }));

package/src/commands/init/templates/common/src/db/tables/master/user.ts.hbs

@@ -0,0 +1,20 @@
+import { Table } from "@simplysm/orm-common";
+import { Role } from "../system/role";
+import { {{userEntityPascal}}Config } from "./{{userEntityKebab}}-config";
+
+export const {{userEntityPascal}} = Table("{{userEntityPascal}}")
+  .description("{{userEntityLabel}}")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    name: c.varchar(100),
+    loginId: c.varchar(50),
+    encryptedPassword: c.varchar(200).nullable(),
+    roleId: c.bigint().nullable(),
+    isDeleted: c.boolean(),
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("loginId").unique()])
+  .relations((r) => ({
+    role: r.foreignKey(["roleId"], () => Role),
+    configs: r.foreignKeyTarget(() => {{userEntityPascal}}Config, "{{userEntityCamel}}"),
+  }));

package/src/commands/init/templates/common/src/db/tables/system/role-permission.ts.hbs

@@ -0,0 +1,16 @@
+import { Table } from "@simplysm/orm-common";
+import { Role } from "./role";
+
+export const RolePermission = Table("RolePermission")
+  .description("역할 권한")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    roleId: c.bigint(),
+    code: c.varchar(200),
+    valueJson: c.text(),
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("roleId", "code").unique()])
+  .relations((r) => ({
+    role: r.foreignKey(["roleId"], () => Role),
+  }));

package/src/commands/init/templates/common/src/db/tables/system/role.ts.hbs

@@ -0,0 +1,16 @@
+import { Table } from "@simplysm/orm-common";
+import { {{userEntityPascal}} } from "../master/{{userEntityKebab}}";
+import { RolePermission } from "./role-permission";
+
+export const Role = Table("Role")
+  .description("역할")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    name: c.varchar(100),
+    isDeleted: c.boolean(),
+  }))
+  .primaryKey("id")
+  .relations((r) => ({
+    {{userEntityCamel}}s: r.foreignKeyTarget(() => {{userEntityPascal}}, "role"),
+    permissions: r.foreignKeyTarget(() => RolePermission, "role"),
+  }));

package/src/commands/init/templates/common/src/db/tables/system/system-data-log.ts.hbs

@@ -0,0 +1,23 @@
+import { Table } from "@simplysm/orm-common";
+{{#if hasAuth}}
+import { {{userEntityPascal}} } from "../master/{{userEntityKebab}}";
+{{/if}}
+
+export const SystemDataLog = Table("SystemDataLog")
+  .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(),
+{{#if hasAuth}}
+    {{userEntityCamel}}Id: c.bigint().nullable(),
+{{/if}}
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("tableName", "itemId"), i.index("dateTime").orderBy("DESC")]){{#if hasAuth}}
+  .relations((r) => ({
+    {{userEntityCamel}}: r.foreignKey(["{{userEntityCamel}}Id"], () => {{userEntityPascal}}),
+  })){{/if}};

package/src/commands/init/templates/common/src/db/tables/system/system-log.ts.hbs

@@ -0,0 +1,21 @@
+import { Table } from "@simplysm/orm-common";
+{{#if hasAuth}}
+import { {{userEntityPascal}} } from "../master/{{userEntityKebab}}";
+{{/if}}
+
+export const SystemLog = Table("SystemLog")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    dateTime: c.datetime(),
+    severity: c.varchar(50),
+    message: c.text(),
+    clientName: c.varchar(200),
+{{#if hasAuth}}
+    {{userEntityCamel}}Id: c.bigint().nullable(),
+{{/if}}
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("dateTime").orderBy("DESC")]){{#if hasAuth}}
+  .relations((r) => ({
+    {{userEntityCamel}}: r.foreignKey(["{{userEntityCamel}}Id"], () => {{userEntityPascal}}),
+  })){{/if}};

package/src/commands/init/templates/common/src/index.ts.hbs

@@ -1,5 +1,18 @@
 {{#if hasDb}}
-export * from "./{{dbContextClassName}}";
+export * from "./{{dbFolderName}}/{{dbContextFileName}}";
+{{#if hasAuth}}
+export * from "./{{dbFolderName}}/tables/master/{{userEntityKebab}}";
+export * from "./{{dbFolderName}}/tables/master/{{userEntityKebab}}-config";
+export * from "./{{dbFolderName}}/tables/system/role";
+export * from "./{{dbFolderName}}/tables/system/role-permission";
+{{/if}}
+export * from "./{{dbFolderName}}/tables/system/system-data-log";
+export * from "./{{dbFolderName}}/tables/system/system-log";
+export * from "./{{dbFolderName}}/system-data-log.ext";
+{{#if hasAuth}}
+export * from "./app-structure";
+export * from "./auth-info-changed.event";
+{{/if}}
 {{else}}
 export {};
 {{/if}}

package/src/commands/init/templates/server/package.json.hbs

@@ -14,10 +14,14 @@
     "@simplysm/orm-common": "^14.0.0",
     "@simplysm/orm-node": "^14.0.0"{{#if isMysql}},
     "mysql2": "^3.22.0"{{/if}}{{#if isPostgres}},
-    "pg": "^8.13.0"{{/if}}{{#if isMssql}},
-    "mssql": "^11.0.0"{{/if}}{{/if}}
+    "pg": "^8.13.0",
+    "pg-copy-streams": "^7.0.0"{{/if}}{{#if isMssql}},
+    "mssql": "^11.0.0"{{/if}}{{/if}}{{#if hasAuth}},
+    "@simplysm/excel": "^14.0.0",
+    "bcrypt": "^6.0.0"{{/if}}
   },
   "devDependencies": {
-    "@types/node": "^20.19.0"
+    "@types/node": "^20.19.0"{{#if hasAuth}},
+    "@types/bcrypt": "^6.0.0"{{/if}}
   }
 }

package/src/commands/init/templates/server/src/index.ts.hbs

@@ -0,0 +1,4 @@
+{{#if hasAuth}}
+export type * from "./services/auth.service";
+{{/if}}
+export type * from "./services/dev.service";

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

@@ -2,6 +2,16 @@ import path from "node:path";
 import { env, num, parseBoolEnv } from "@simplysm/core-common";
 import { setupConsola } from "@simplysm/core-node";
 import { createServiceServer, getConfig{{#if hasDb}}, OrmService{{/if}} } from "@simplysm/service-server";
+import { EventEmitter } from "node:events";
+{{#if hasAuth}}
+import { AuthService } from "./services/auth.service";
+{{/if}}
+{{#if hasDb}}
+import { DevService } from "./services/dev.service";
+{{/if}}
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
 
 setupConsola();
 
@@ -15,7 +25,7 @@ if (authConfig?.jwtSecret == null) {
 
 export const server = createServiceServer({
   rootPath: import.meta.dirname,
-  services: [{{#if hasDb}}OrmService{{/if}}],
+  services: [{{#if hasDb}}OrmService{{#if hasAuth}}, AuthService{{/if}}, ...(parseBoolEnv(env("DEV")) ? [DevService] : []){{/if}}],
   port: num.parseInt(env("SERVER_PORT"))!,
   auth: { jwtSecret: authConfig.jwtSecret },
 });

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

@@ -0,0 +1,284 @@
+import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
+import { expr } from "@simplysm/orm-common";
+import { AuthInfoChangedEvent, {{userEntityPascal}}Config, RolePermission } from "@{{workspaceName}}/common";
+import bcrypt from "bcrypt";
+import { getOrm } from "../utils/orm.utils";
+
+export interface I{{userEntityPascal}}ConfigMap {
+  "first-router-link"?: string;
+}
+
+export interface IAuthData {
+  {{userEntityCamel}}Id: number;
+  name: string;
+  roleName: string;
+  loginId: string;
+  permissions: Record<string, boolean>;
+  configs: I{{userEntityPascal}}ConfigMap;
+}
+
+export interface IAuthResult extends IAuthData {
+  token: string;
+}
+
+export const AuthService = defineService("AuthService", (ctx) => {
+  async function buildAuthResult({{userEntityCamel}}: {
+    id: number;
+    name: string;
+    loginId: string;
+    role?: { id: number; name: string };
+    permissions?: { code: string; valueJson: string }[];
+    configs?: { code: string; valueJson: string }[];
+  }): Promise<IAuthResult> {
+    const permissions: Record<string, boolean> = {};
+    for (const rp of {{userEntityCamel}}.permissions ?? []) {
+      permissions[rp.code] = JSON.parse(rp.valueJson) as boolean;
+    }
+
+    const configs: I{{userEntityPascal}}ConfigMap = {};
+    for (const cfg of {{userEntityCamel}}.configs ?? []) {
+      (configs as Record<string, unknown>)[cfg.code] = JSON.parse(cfg.valueJson);
+    }
+
+    const authData: IAuthData = {
+      {{userEntityCamel}}Id: {{userEntityCamel}}.id,
+      name: {{userEntityCamel}}.name,
+      roleName: {{userEntityCamel}}.role!.name,
+      loginId: {{userEntityCamel}}.loginId,
+      permissions,
+      configs,
+    };
+
+    const token = await ctx.server.signAuthToken({
+      roles: [],
+      data: authData,
+    });
+
+    return { token, ...authData };
+  }
+
+  return {
+    login: async (loginId: string, password: string): Promise<IAuthResult> => {
+      if (loginId.length === 0 || loginId.length > 50) {
+        throw new Error("아이디는 1~50자의 문자열이어야 합니다.");
+      }
+
+      if (password.length === 0 || password.length > 500) {
+        throw new Error("비밀번호는 1~500자의 문자열이어야 합니다.");
+      }
+
+      const orm = await getOrm(ctx);
+      return orm.connect(async (db) => {
+        const {{userEntityCamel}} = await db
+          .{{userEntityCamel}}()
+          .where((c) => [expr.eq(c.loginId, loginId)])
+          .join("permissions", (qr, e) =>
+            qr
+              .from(RolePermission)
+              .where((rp) => [expr.eq(rp.roleId, e.roleId)])
+              .select((rp) => ({ code: rp.code, valueJson: rp.valueJson })),
+          )
+          .join("configs", (qr, e) =>
+            qr
+              .from({{userEntityPascal}}Config)
+              .where((cfg) => [expr.eq(cfg.{{userEntityCamel}}Id, e.id)])
+              .select((cfg) => ({ code: cfg.code, valueJson: cfg.valueJson })),
+          )
+          .include((item) => item.role)
+          .select((item) => ({
+            id: item.id,
+            name: item.name,
+            loginId: item.loginId,
+            encryptedPassword: item.encryptedPassword,
+            role: item.role,
+            permissions: item.permissions?.map((it) => ({
+              code: it.code,
+              valueJson: it.valueJson,
+            })),
+            configs: item.configs?.map((it) => ({
+              code: it.code,
+              valueJson: it.valueJson,
+            })),
+          }))
+          .single();
+
+        if (!{{userEntityCamel}}) {
+          throw new Error("아이디 또는 비밀번호가 올바르지 않습니다.");
+        }
+
+        if ({{userEntityCamel}}.encryptedPassword == null || {{userEntityCamel}}.encryptedPassword === "") {
+          throw new Error("비밀번호가 설정되지 않은 계정입니다.");
+        }
+
+        if ({{userEntityCamel}}.role == null) {
+          throw new Error("권한이 부여되지 않은 계정입니다.");
+        }
+
+        const isValid = await bcrypt.compare(password, {{userEntityCamel}}.encryptedPassword);
+        if (!isValid) {
+          throw new Error("아이디 또는 비밀번호가 올바르지 않습니다.");
+        }
+
+        return buildAuthResult({{userEntityCamel}});
+      });
+    },
+
+    refresh: auth(async (): Promise<IAuthResult> => {
+      const currentAuth = ctx.authInfo as IAuthData | undefined;
+      if (!currentAuth) {
+        throw new Error("인증 정보가 없습니다.");
+      }
+
+      const orm = await getOrm(ctx);
+      return orm.connect(async (db) => {
+        const {{userEntityCamel}} = await db
+          .{{userEntityCamel}}()
+          .where((c) => [expr.eq(c.id, currentAuth.{{userEntityCamel}}Id)])
+          .join("permissions", (qr, e) =>
+            qr
+              .from(RolePermission)
+              .where((rp) => [expr.eq(rp.roleId, e.roleId)])
+              .select((rp) => ({ code: rp.code, valueJson: rp.valueJson })),
+          )
+          .join("configs", (qr, e) =>
+            qr
+              .from({{userEntityPascal}}Config)
+              .where((cfg) => [expr.eq(cfg.{{userEntityCamel}}Id, e.id)])
+              .select((cfg) => ({ code: cfg.code, valueJson: cfg.valueJson })),
+          )
+          .include((item) => item.role)
+          .select((item) => ({
+            id: item.id,
+            name: item.name,
+            loginId: item.loginId,
+            encryptedPassword: item.encryptedPassword,
+            role: item.role,
+            permissions: item.permissions?.map((it) => ({
+              code: it.code,
+              valueJson: it.valueJson,
+            })),
+            configs: item.configs?.map((it) => ({
+              code: it.code,
+              valueJson: it.valueJson,
+            })),
+          }))
+          .single();
+
+        if (!{{userEntityCamel}}) {
+          throw new Error("유효하지 않은 {{userEntityLabel}}입니다.");
+        }
+
+        if ({{userEntityCamel}}.encryptedPassword == null || {{userEntityCamel}}.encryptedPassword === "") {
+          throw new Error("비밀번호가 설정되지 않은 계정입니다.");
+        }
+
+        if ({{userEntityCamel}}.role == null) {
+          throw new Error("권한이 부여되지 않은 계정입니다.");
+        }
+
+        return buildAuthResult({{userEntityCamel}});
+      });
+    }),
+
+    update: auth(
+      async (input: {
+        configs: I{{userEntityPascal}}ConfigMap;
+        currentPassword?: string;
+        newPassword?: string;
+      }): Promise<void> => {
+        const currentAuth = ctx.authInfo as IAuthData | undefined;
+        if (!currentAuth) {
+          throw new Error("인증 정보가 없습니다.");
+        }
+        const {{userEntityCamel}}Id = currentAuth.{{userEntityCamel}}Id;
+
+        const isChangingPassword = !(input.newPassword == null || input.newPassword === "");
+        if (isChangingPassword) {
+          if (input.newPassword!.length > 500) {
+            throw new Error("비밀번호는 1~500자의 문자열이어야 합니다.");
+          }
+          if (input.currentPassword == null || input.currentPassword === "") {
+            throw new Error("기존 비밀번호를 입력하세요.");
+          }
+        }
+
+        const orm = await getOrm(ctx);
+        await orm.connect(async (db) => {
+          // 1) 비밀번호 변경(입력 시): 기존 비밀번호 검증 후 해시 갱신
+          if (isChangingPassword) {
+            const target = await db
+              .{{userEntityCamel}}()
+              .where((c) => [expr.eq(c.id, {{userEntityCamel}}Id)])
+              .select((item) => ({ encryptedPassword: item.encryptedPassword }))
+              .single();
+            if (!target) {
+              throw new Error("유효하지 않은 {{userEntityLabel}}입니다.");
+            }
+            if (target.encryptedPassword == null || target.encryptedPassword === "") {
+              throw new Error("비밀번호가 설정되지 않은 계정입니다.");
+            }
+
+            const isValid = await bcrypt.compare(input.currentPassword!, target.encryptedPassword);
+            if (!isValid) {
+              throw new Error("기존 비밀번호가 올바르지 않습니다.");
+            }
+
+            const newEncryptedPassword = await bcrypt.hash(input.newPassword!, 10);
+            await db
+              .{{userEntityCamel}}()
+              .where((c) => [expr.eq(c.id, {{userEntityCamel}}Id)])
+              .update(() => ({ encryptedPassword: newEncryptedPassword }));
+          }
+
+          // 2) 시스템설정 동기화: input.configs 에 없는 코드는 삭제, 있는 코드는 upsert
+          const codes = Object.keys(input.configs).filter(
+            (code) => (input.configs as Record<string, unknown>)[code] != null,
+          );
+          const existingConfigs = await db
+            .{{userEntityCamel}}Config()
+            .where((c) => [expr.eq(c.{{userEntityCamel}}Id, {{userEntityCamel}}Id)])
+            .select((c) => ({ code: c.code }))
+            .execute();
+          for (const existing of existingConfigs) {
+            if (!codes.includes(existing.code)) {
+              await db
+                .{{userEntityCamel}}Config()
+                .where((c) => [expr.eq(c.{{userEntityCamel}}Id, {{userEntityCamel}}Id), expr.eq(c.code, existing.code)])
+                .delete();
+            }
+          }
+          for (const code of codes) {
+            const valueJson = JSON.stringify((input.configs as Record<string, unknown>)[code]);
+            await db
+              .{{userEntityCamel}}Config()
+              .where((c) => [expr.eq(c.{{userEntityCamel}}Id, {{userEntityCamel}}Id), expr.eq(c.code, code)])
+              .upsert(
+                () => ({ valueJson }),
+                (up) => ({
+                  ...up,
+                  {{userEntityCamel}}Id,
+                  code,
+                }),
+              );
+          }
+
+          // 3) 데이터 변경이력
+          await db.{{userEntityCamel}}().insertDataLog({
+            action: "수정(내정보수정)",
+            itemId: {{userEntityCamel}}Id,
+            {{userEntityCamel}}Id,
+          });
+        });
+
+        // 4) 인증정보 변경 이벤트 발생 → 본인 세션 포함 구독자가 authInfo 재로드
+        await ctx.server.emitEvent(
+          AuthInfoChangedEvent,
+          (info) => info.{{userEntityCamel}}Id === {{userEntityCamel}}Id,
+          undefined,
+        );
+      },
+    ),
+  };
+});
+
+export type AuthServiceMethods = ServiceMethods<typeof AuthService>;