@simplysm/sd-cli 14.0.95 → 14.0.97

package/src/commands/init/templates/client-common/src/providers/app-service.provider.ts.hbs

@@ -2,20 +2,25 @@ import { inject, Injectable } from "@angular/core";
 import { SdServiceClientFactoryProvider } from "@simplysm/angular";
 import { env, num, parseBoolEnv } from "@simplysm/core-common";
 {{#if hasDb}}
+import type {
+{{#if hasAuth}}
+  AuthServiceMethods,
+{{/if}}
+  DevServiceMethods,
+{{#if hasAuth}}
+  {{userEntityPascal}}ServiceMethods,
+{{/if}}
+} from "@{{workspaceName}}/server";
 import {
-  createOrmClientConnector,
-  type OrmClientConnector,
-  type ServiceProxy,
 {{#if hasAuth}}
   type ClientEventProxy,
 {{/if}}
+  createOrmClientConnector,
+  type OrmClientConnector,
+  type ServiceProxy,
 } from "@simplysm/service-client";
 {{/if}}
-{{#if hasDb}}
-import type { DevServiceMethods } from "@{{workspaceName}}/server";
-{{/if}}
 {{#if hasAuth}}
-import type { AuthServiceMethods } from "@{{workspaceName}}/server";
 import { AuthInfoChangedEvent } from "@{{workspaceName}}/common";
 {{/if}}
 
@@ -34,6 +39,15 @@ export class AppServiceProvider {
   get orm(): OrmClientConnector {
     return (this._orm ??= createOrmClientConnector(this.client));
   }
+{{/if}}
+{{#if hasAuth}}
+
+  private _auth?: ServiceProxy<AuthServiceMethods>;
+  get auth(): ServiceProxy<AuthServiceMethods> {
+    return (this._auth ??= this.client.getService<AuthServiceMethods>("AuthService"));
+  }
+{{/if}}
+{{#if hasDb}}
 
   private _dev?: ServiceProxy<DevServiceMethods>;
   get dev(): ServiceProxy<DevServiceMethods> {
@@ -42,9 +56,9 @@ export class AppServiceProvider {
 {{/if}}
 {{#if hasAuth}}
 
-  private _auth?: ServiceProxy<AuthServiceMethods>;
-  get auth(): ServiceProxy<AuthServiceMethods> {
-    return (this._auth ??= this.client.getService<AuthServiceMethods>("AuthService"));
+  private _{{userEntityCamel}}?: ServiceProxy<{{userEntityPascal}}ServiceMethods>;
+  get {{userEntityCamel}}(): ServiceProxy<{{userEntityPascal}}ServiceMethods> {
+    return (this._{{userEntityCamel}} ??= this.client.getService<{{userEntityPascal}}ServiceMethods>("{{userEntityPascal}}Service"));
   }
 
   private _authInfoChangedEvent?: ClientEventProxy<typeof AuthInfoChangedEvent>;

package/src/commands/init/templates/client-common/src/providers/app-shared-data.provider.ts.hbs

@@ -12,10 +12,10 @@ import { AppOrmProvider } from "./app-orm.provider";
 {{/if}}
 
 export function useSharedSignal<K extends keyof TAppSharedData>(
-  name: K,
+  dataKey: K,
 ): SharedDataHandle<TAppSharedData[K]> {
   const appSharedData = inject(AppSharedDataProvider);
-  return appSharedData.getHandle(name);
+  return appSharedData.getHandle(dataKey);
 }
 
 @Injectable({ providedIn: "root" })

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

@@ -6,6 +6,7 @@
   "dependencies": {
     "@simplysm/core-common": "^14.0.0"{{#if hasDb}},
     "@simplysm/orm-common": "^14.0.0"{{/if}}{{#if hasAuth}},
-    "@simplysm/service-common": "^14.0.0"{{/if}}
+    "@simplysm/service-common": "^14.0.0",
+    "@ng-icons/tabler-icons": "^33.2.3"{{/if}}
   }
 }

package/src/commands/init/templates/common/src/app-structure.ts.hbs

@@ -1,13 +1,18 @@
 import type { AppStructureItem } from "@simplysm/service-common";
+import { tablerDatabase, tablerSettings } from "@ng-icons/tabler-icons";
 
 {{#each appStructureNames}}
+{{#unless @first}}
+
+{{/unless}}
 export const {{this}}: AppStructureItem[] = [
   { title: "메인화면", code: "main", isNotMenu: true },
   { title: "내 정보 수정", code: "my-info", isNotMenu: true },
 
   {
-    code: "base",
+    code: "master",
     title: "기준정보",
+    icon: tablerDatabase,
     children: [
       { code: "role-permission", title: "역할/권한", perms: ["use", "edit"] },
       { code: "{{../userEntityKebab}}", title: "{{../userEntityLabel}}", perms: ["use", "edit"] },
@@ -16,11 +21,11 @@ export const {{this}}: AppStructureItem[] = [
   {
     code: "system",
     title: "시스템",
+    icon: tablerSettings,
     children: [
       { code: "data-log", title: "데이터 변경내역", perms: ["use"] },
       { code: "system-log", title: "시스템 로그", perms: ["use"] },
     ],
   },
 ];
-
 {{/each}}

package/src/commands/init/templates/common/src/auth-info-changed.event.ts.hbs

@@ -1,3 +1,5 @@
 import { defineEvent } from "@simplysm/service-common";
 
-export const AuthInfoChangedEvent = defineEvent<{ {{userEntityCamel}}Id: number }, void>("AuthInfoChanged");
+export const AuthInfoChangedEvent = defineEvent<{ {{userEntityCamel}}Id: number; roleId: number }, void>(
+  "AuthInfoChanged",
+);

package/src/commands/init/templates/common/src/db/db-context.ts.hbs

@@ -1,8 +1,8 @@
 import { DbContext } from "@simplysm/orm-common";
 {{#if hasAuth}}
 import { {{userEntityPascal}} } from "./tables/master/{{userEntityKebab}}";
-import { {{userEntityPascal}}Config } from "./tables/master/{{userEntityKebab}}-config";
 import { Role } from "./tables/system/role";
+import { {{userEntityPascal}}Config } from "./tables/master/{{userEntityKebab}}-config";
 import { RolePermission } from "./tables/system/role-permission";
 {{/if}}
 import { SystemDataLog } from "./tables/system/system-data-log";
@@ -11,8 +11,8 @@ import { SystemLog } from "./tables/system/system-log";
 export class {{dbContextClassName}} extends DbContext {
 {{#if hasAuth}}
   {{userEntityCamel}} = this.queryable({{userEntityPascal}});
-  {{userEntityCamel}}Config = this.queryable({{userEntityPascal}}Config);
   role = this.queryable(Role);
+  {{userEntityCamel}}Config = this.queryable({{userEntityPascal}}Config);
   rolePermission = this.queryable(RolePermission);
 {{/if}}
   dataLog = this.queryable(SystemDataLog);

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

@@ -7,13 +7,13 @@ export const {{userEntityPascal}} = Table("{{userEntityPascal}}")
   .columns((c) => ({
     id: c.bigint().autoIncrement(),
     name: c.varchar(100),
-    loginId: c.varchar(50),
+    loginId: c.varchar(50).nullable(),
     encryptedPassword: c.varchar(200).nullable(),
     roleId: c.bigint().nullable(),
     isDeleted: c.boolean(),
   }))
   .primaryKey("id")
-  .indexes((i) => [i.index("loginId").unique()])
+  .indexes((i) => [i.index("loginId").unique(), i.index("name", "isDeleted")])
   .relations((r) => ({
     role: r.foreignKey(["roleId"], () => Role),
     configs: r.foreignKeyTarget(() => {{userEntityPascal}}Config, "{{userEntityCamel}}"),

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

@@ -10,6 +10,7 @@ export const Role = Table("Role")
     isDeleted: c.boolean(),
   }))
   .primaryKey("id")
+  .indexes((i) => [i.index("name", "isDeleted")])
   .relations((r) => ({
     {{userEntityCamel}}s: r.foreignKeyTarget(() => {{userEntityPascal}}, "role"),
     permissions: r.foreignKeyTarget(() => RolePermission, "role"),

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

@@ -2,8 +2,8 @@
 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/master/{{userEntityKebab}}-config";
 export * from "./{{dbFolderName}}/tables/system/role-permission";
 {{/if}}
 export * from "./{{dbFolderName}}/tables/system/system-data-log";

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

@@ -2,3 +2,6 @@
 export type * from "./services/auth.service";
 {{/if}}
 export type * from "./services/dev.service";
+{{#if hasAuth}}
+export type * from "./services/{{userEntityKebab}}.service";
+{{/if}}

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

@@ -9,6 +9,9 @@ import { AuthService } from "./services/auth.service";
 {{#if hasDb}}
 import { DevService } from "./services/dev.service";
 {{/if}}
+{{#if hasAuth}}
+import { {{userEntityPascal}}Service } from "./services/{{userEntityKebab}}.service";
+{{/if}}
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
@@ -25,7 +28,18 @@ if (authConfig?.jwtSecret == null) {
 
 export const server = createServiceServer({
   rootPath: import.meta.dirname,
-  services: [{{#if hasDb}}OrmService{{#if hasAuth}}, AuthService{{/if}}, ...(parseBoolEnv(env("DEV")) ? [DevService] : []){{/if}}],
+  services: [
+{{#if hasDb}}
+    OrmService,
+{{/if}}
+{{#if hasAuth}}
+    AuthService,
+    {{userEntityPascal}}Service,
+{{/if}}
+{{#if hasDb}}
+    ...(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

@@ -10,6 +10,7 @@ export interface I{{userEntityPascal}}ConfigMap {
 
 export interface IAuthData {
   {{userEntityCamel}}Id: number;
+  roleId: number;
   name: string;
   roleName: string;
   loginId: string;
@@ -25,26 +26,33 @@ export const AuthService = defineService("AuthService", (ctx) => {
   async function buildAuthResult({{userEntityCamel}}: {
     id: number;
     name: string;
-    loginId: string;
+    loginId?: string;
     role?: { id: number; name: string };
     permissions?: { code: string; valueJson: string }[];
     configs?: { code: string; valueJson: string }[];
   }): Promise<IAuthResult> {
+    // 인증된 사용자는 loginId 가 반드시 존재(로그인으로 식별됨). 없으면 인증 불가 상태이므로 throw.
+    if ({{userEntityCamel}}.loginId == null) {
+      throw new Error("로그인 ID가 없는 계정입니다.");
+    }
+    const loginId = {{userEntityCamel}}.loginId;
+
     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);
+    for (const c of {{userEntityCamel}}.configs ?? []) {
+      (configs as Record<string, unknown>)[c.code] = JSON.parse(c.valueJson);
     }
 
     const authData: IAuthData = {
       {{userEntityCamel}}Id: {{userEntityCamel}}.id,
+      roleId: {{userEntityCamel}}.role!.id,
       name: {{userEntityCamel}}.name,
       roleName: {{userEntityCamel}}.role!.name,
-      loginId: {{userEntityCamel}}.loginId,
+      loginId,
       permissions,
       configs,
     };
@@ -72,6 +80,7 @@ export const AuthService = defineService("AuthService", (ctx) => {
         const {{userEntityCamel}} = await db
           .{{userEntityCamel}}()
           .where((c) => [expr.eq(c.loginId, loginId)])
+          .include((item) => item.role)
           .join("permissions", (qr, e) =>
             qr
               .from(RolePermission)
@@ -81,10 +90,9 @@ export const AuthService = defineService("AuthService", (ctx) => {
           .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 })),
+              .where((ec) => [expr.eq(ec.{{userEntityCamel}}Id, e.id)])
+              .select((ec) => ({ code: ec.code, valueJson: ec.valueJson })),
           )
-          .include((item) => item.role)
           .select((item) => ({
             id: item.id,
             name: item.name,
@@ -133,6 +141,7 @@ export const AuthService = defineService("AuthService", (ctx) => {
       return orm.connect(async (db) => {
         const {{userEntityCamel}} = await db
           .{{userEntityCamel}}()
+          .include((item) => item.role)
           .where((c) => [expr.eq(c.id, currentAuth.{{userEntityCamel}}Id)])
           .join("permissions", (qr, e) =>
             qr
@@ -143,10 +152,9 @@ export const AuthService = defineService("AuthService", (ctx) => {
           .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 })),
+              .where((ec) => [expr.eq(ec.{{userEntityCamel}}Id, e.id)])
+              .select((ec) => ({ code: ec.code, valueJson: ec.valueJson })),
           )
-          .include((item) => item.role)
           .select((item) => ({
             id: item.id,
             name: item.name,
@@ -234,18 +242,16 @@ export const AuthService = defineService("AuthService", (ctx) => {
           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();
-            }
+          if (codes.length === 0) {
+            await db
+              .{{userEntityCamel}}Config()
+              .where((c) => [expr.eq(c.{{userEntityCamel}}Id, {{userEntityCamel}}Id)])
+              .delete();
+          } else {
+            await db
+              .{{userEntityCamel}}Config()
+              .where((c) => [expr.eq(c.{{userEntityCamel}}Id, {{userEntityCamel}}Id), expr.not(expr.in(c.code, codes))])
+              .delete();
           }
           for (const code of codes) {
             const valueJson = JSON.stringify((input.configs as Record<string, unknown>)[code]);

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

@@ -78,11 +78,13 @@ export const DevService = defineService("DevService", (ctx) => {
 
           if ("역할권한" in excelData) {
             const allPermCodes = getFlatPermissions(
+{{#if appStructureNames.[1]}}
               [{{#each appStructureNames}}...{{this}}{{#unless @last}}, {{/unless}}{{/each}}],
+{{else}}
+              {{appStructureNames.[0]}},
+{{/if}}
               undefined,
-            )
-              .map((p) => p.codeChain.join("."))
-              .distinct();
+            ).map((p) => p.codeChain.join("."));
             await db.rolePermission().insert(
               excelData["역할권한"]
                 .filter((r) => r["역할.ID"] != null)
@@ -98,8 +100,6 @@ export const DevService = defineService("DevService", (ctx) => {
             );
             await db.rolePermission().insertDataLog({ action: "초기화" });
           }
-
-          // TODO: 업무 테이블 초기 데이터 시드 추가
         });
 {{else}}
         // TODO: 초기 데이터 시드 추가

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

@@ -0,0 +1,191 @@
+import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
+import { expr } from "@simplysm/orm-common";
+import bcrypt from "bcrypt";
+import { getOrm } from "../utils/orm.utils";
+import type { IAuthData } from "./auth.service";
+
+export interface I{{userEntityPascal}}SaveInput {
+  id?: number;
+  name: string;
+  loginId?: string;
+  roleId?: number;
+  password?: string;
+  isDeleted?: boolean;
+}
+
+export const {{userEntityPascal}}Service = defineService("{{userEntityPascal}}Service", (ctx) => {
+  return {
+    // {{userEntityLabel}} 등록/수정 일괄 처리. 비밀번호는 bcrypt 해시(브라우저 실행 불가 + 보안)라 서버에서 처리.
+    // 전체를 한 트랜잭션으로 처리 — 한 건이라도 실패하면 전부 롤백(원자성).
+    save: auth(async (inputs: I{{userEntityPascal}}SaveInput[]): Promise<{ id: number }[]> => {
+      const currentAuth = ctx.authInfo as IAuthData | undefined;
+      if (!currentAuth) {
+        throw new Error("인증 정보가 없습니다.");
+      }
+      const performerId = currentAuth.{{userEntityCamel}}Id;
+
+      // 에러 식별 접두사 — 단건(상세 화면)이면 생략, 다건(엑셀 업로드)이면 이름으로 표기.
+      const label = ({{userEntityCamel}}Name: string): string =>
+        inputs.length > 1 ? `{{userEntityLabel}} '${ {{~userEntityCamel}}Name}': ` : "";
+
+      // 행별 형식 검증 + 정규화 (DB 접근 전).
+      const rows = inputs.map((input) => {
+        const {{userEntityCamel}}Name = input.name.trim();
+        if ({{userEntityCamel}}Name === "" || {{userEntityCamel}}Name.length > 100) {
+          throw new Error(`${label({{userEntityCamel}}Name)}이름은 1~100자의 문자열이어야 합니다.`);
+        }
+
+        // 로그인ID 는 선택값(로그인 안 하는 {{userEntityLabel}}). 빈 문자열은 NULL 로 정규화.
+        const trimmedLoginId = input.loginId?.trim();
+        const loginId =
+          trimmedLoginId != null && trimmedLoginId !== "" ? trimmedLoginId : undefined;
+        if (loginId != null && loginId.length > 50) {
+          throw new Error(`${label({{userEntityCamel}}Name)}로그인ID는 50자 이하의 문자열이어야 합니다.`);
+        }
+
+        const password =
+          input.password != null && input.password !== "" ? input.password : undefined;
+        if (password != null && password.length > 500) {
+          throw new Error(`${label({{userEntityCamel}}Name)}비밀번호는 1~500자의 문자열이어야 합니다.`);
+        }
+
+        return {
+          id: input.id,
+          name: {{userEntityCamel}}Name,
+          loginId,
+          roleId: input.roleId,
+          password,
+          isDeleted: input.isDeleted,
+        };
+      });
+
+      // 배치 내 로그인ID 중복 검증 — 같은 업로드 안의 충돌은 DB 검사로 못 잡으므로 여기서 차단.
+      // (이름 활성유니크는 행 반영 후 한 번에 후검증 — 아래 참조.)
+      const findDuplicate = (values: (string | undefined)[]): string | undefined => {
+        const seen = new Set<string>();
+        for (const value of values) {
+          if (value == null) continue;
+          if (seen.has(value)) return value;
+          seen.add(value);
+        }
+        return undefined;
+      };
+      const dupLoginId = findDuplicate(rows.map((r) => r.loginId));
+      if (dupLoginId != null) {
+        throw new Error(`업로드 내 로그인ID가 중복됩니다: '${dupLoginId}'`);
+      }
+
+      const orm = await getOrm(ctx);
+      return orm.connect(async (db) => {
+        const results: { id: number }[] = [];
+        const activeNames: string[] = [];
+
+        for (const { id, name, loginId, roleId, password, isDeleted } of rows) {
+          // 수정 대상이면 기존 레코드 확인 — id 존재 강제 + 불변식·이력전이 판정에 기존 상태 필요.
+          let existingEncryptedPassword: string | undefined;
+          let existingIsDeleted: boolean | undefined;
+          if (id != null) {
+            const existing = await db
+              .{{userEntityCamel}}()
+              .where((c) => [expr.eq(c.id, id)])
+              .select((c) => ({
+                encryptedPassword: c.encryptedPassword,
+                isDeleted: c.isDeleted,
+              }))
+              .single();
+            if (existing == null) {
+              throw new Error(`${label(name)}존재하지 않는 {{userEntityLabel}}입니다. (ID: ${id})`);
+            }
+            existingEncryptedPassword = existing.encryptedPassword ?? undefined;
+            existingIsDeleted = existing.isDeleted;
+          }
+
+          // 저장 후 삭제상태 — 입력값 우선, 없으면(상세 화면) 기존 유지, 신규는 활성(false).
+          const resultIsDeleted = isDeleted ?? existingIsDeleted ?? false;
+          // 활성으로 귀결되는 이름은 후검증(활성유니크) 대상으로 수집.
+          if (!resultIsDeleted) {
+            activeNames.push(name);
+          }
+
+          // 불변식: 로그인ID 가 있으면 역할·비밀번호 필수 (비번은 이번 입력 또는 수정 시 기존 해시로 충족).
+          if (loginId != null) {
+            if (roleId == null) {
+              throw new Error(`${label(name)}로그인ID가 있으면 역할이 필수입니다.`);
+            }
+            if (password == null && existingEncryptedPassword == null) {
+              throw new Error(`${label(name)}로그인ID가 있으면 비밀번호가 필수입니다.`);
+            }
+          }
+
+          // 로그인ID 중복검증 (자기 자신 제외). loginId 는 DB 유니크 인덱스라 삭제 건도 포함해 검사.
+          if (loginId != null) {
+            const isDuplicated = await db
+              .{{userEntityCamel}}()
+              .where((c) => [
+                expr.eq(c.loginId, loginId),
+                ...(id == null ? [] : [expr.not(expr.eq(c.id, id))]),
+              ])
+              .exists();
+            if (isDuplicated) {
+              throw new Error(`${label(name)}이미 사용 중인 로그인ID입니다.`);
+            }
+          }
+
+          const encryptedPassword =
+            password != null ? await bcrypt.hash(password, 10) : undefined;
+
+          if (id == null) {
+            const [inserted] = await db
+              .{{userEntityCamel}}()
+              .insert([{ name, loginId, encryptedPassword, roleId, isDeleted: resultIsDeleted }], [
+                "id",
+              ]);
+            await db.{{userEntityCamel}}().insertDataLog({
+              action: "등록",
+              itemId: inserted.id,
+              {{userEntityCamel}}Id: performerId,
+            });
+            results.push({ id: inserted.id });
+          } else {
+            // 비밀번호 미입력 시 기존 해시 유지 — encryptedPassword 키를 set 에서 제외.
+            await db
+              .{{userEntityCamel}}()
+              .where((c) => [expr.eq(c.id, id)])
+              .update(() => ({
+                name,
+                loginId,
+                roleId,
+                isDeleted: resultIsDeleted,
+                ...(encryptedPassword == null ? {} : { encryptedPassword }),
+              }));
+            // 삭제상태 전이에 따른 이력 action.
+            const action =
+              existingIsDeleted === resultIsDeleted ? "수정" : resultIsDeleted ? "삭제" : "복구";
+            await db.{{userEntityCamel}}().insertDataLog({ action, itemId: id, {{userEntityCamel}}Id: performerId });
+            results.push({ id });
+          }
+        }
+
+        // 이름 활성유니크 후검증 — 모든 행 반영 후, 활성으로 귀결된 이름 중 활성 중복이 있으면 throw(전체 롤백).
+        // 벌크는 처리 전 상태로는 대상끼리 충돌을 못 보므로 후검증. 삭제 행은 제외돼 동명이 허용된다.
+        if (activeNames.length > 0) {
+          const conflicts = await db
+            .{{userEntityCamel}}()
+            .where((c) => [expr.in(c.name, activeNames), expr.eq(c.isDeleted, false)])
+            .groupBy((c) => [c.name])
+            .having(() => [expr.gt(expr.count(), 1)])
+            .select((c) => ({ name: c.name }))
+            .execute();
+          if (conflicts.length > 0) {
+            const conflictNames = conflicts.map((x) => `'${x.name}'`).join(", ");
+            throw new Error(`이미 존재하는 {{userEntityLabel}} 이름: ${conflictNames}`);
+          }
+        }
+
+        return results;
+      });
+    }),
+  };
+});
+
+export type {{userEntityPascal}}ServiceMethods = ServiceMethods<typeof {{userEntityPascal}}Service>;

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

@@ -44,6 +44,9 @@ const config: SdConfigFn = () => ({
 {{#if ../hasServer}}
       server: "server",
 {{/if}}
+{{#if useSsg}}
+      prerender: ["/"],
+{{/if}}
 {{#if isMobile}}
       pwa: false,
       capacitor: {

package/src/commands/init/types.ts

@@ -5,6 +5,8 @@ export interface ClientInputSpec {
   name: string;
   type: ClientType;
   hasRouter: boolean;
+  /** SSG(빌드 타임 프리렌더) 사용 여부 (web + 라우팅 클라이언트만) */
+  useSsg?: boolean;
 }
 
 export interface InitInput {
@@ -29,6 +31,7 @@ export interface ClientSpec {
   isMobile: boolean;
   appStructureName: string;
   needsNgIcons: boolean;
+  useSsg: boolean;
 }
 
 export interface NormalizedInput {

package/src/engines/EsbuildClientEngine.ts

@@ -72,6 +72,7 @@ export class EsbuildClientEngine implements BuildEngine {
       outDir: this._outDir,
       base: this._base,
       browserSupport: this._pkg.config.browserSupport,
+      prerender: this._pkg.config.prerender,
     });
 
     logger.debug(`[${this._pkg.name}] EsbuildClientEngine.run 완료 (success: ${result.success})`);

package/src/esbuild/esbuild-client-config.ts

@@ -1,9 +1,7 @@
 import path from "path";
 import fs from "fs";
-import { createRequire } from "module";
 import esbuild from "esbuild";
 import browserslistToEsbuild from "browserslist-to-esbuild";
-import type { AcceptedPlugin } from "postcss";
 import { AngularSourceFileCache } from "../angular/angular-compiler.js";
 import { createClientTransformStylesheet } from "../angular/client-transform-stylesheet.js";
 import {
@@ -12,7 +10,7 @@ import {
 } from "./esbuild-angular-compiler-plugin.js";
 import { MemoryLoadResultCache } from "./load-result-cache.js";
 import { createScssPlugin } from "./esbuild-scss-plugin";
-import { createPostcssPlugin } from "./esbuild-postcss-plugin";
+import { createPostcssPlugin, loadPostcssPlugins } from "./esbuild-postcss-plugin";
 
 export interface CreateClientEsbuildOptions {
   /** 패키지 디렉토리 경로 */
@@ -82,15 +80,7 @@ export async function createClientEsbuildContext(
   const stylesheetErrors: string[] = [];
 
   // PostCSS 플러그인 로딩 (튜플 → 인스턴스) — transformStylesheet와 createPostcssPlugin 양쪽에 사용
-  let loadedPostcssPlugins: AcceptedPlugin[] | undefined;
-  if (options.postcssPlugins != null && options.postcssPlugins.length > 0) {
-    const req = createRequire(path.join(options.pkgDir, "package.json"));
-    loadedPostcssPlugins = options.postcssPlugins.map(([name, pluginOpts]) => {
-      const pluginFn = req(name);
-      const fn = pluginFn.default ?? pluginFn;
-      return pluginOpts != null ? fn(pluginOpts) : fn;
-    });
-  }
+  const loadedPostcssPlugins = loadPostcssPlugins(options.pkgDir, options.postcssPlugins);
 
   // transformStylesheet 콜백 생성
   const cachePath = path.join(options.pkgDir, ".angular", "cache");

package/src/esbuild/esbuild-postcss-plugin.ts

@@ -2,6 +2,8 @@ import type esbuild from "esbuild";
 import type { AcceptedPlugin } from "postcss";
 import postcss from "postcss";
 import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
 import * as acorn from "acorn";
 import * as walk from "acorn-walk";
 
@@ -10,6 +12,22 @@ export interface CreatePostcssPluginOptions {
   plugins: AcceptedPlugin[];
 }
 
+/**
+ * PostCSS 플러그인 설정 튜플([name, options])을 패키지 기준으로 로딩해 인스턴스 배열로 변환한다.
+ */
+export function loadPostcssPlugins(
+  pkgDir: string,
+  postcssPlugins: [string, (object | string)?][] | undefined,
+): AcceptedPlugin[] | undefined {
+  if (postcssPlugins == null || postcssPlugins.length === 0) return undefined;
+  const req = createRequire(path.join(pkgDir, "package.json"));
+  return postcssPlugins.map(([pluginName, pluginOpts]) => {
+    const pluginFn = req(pluginName);
+    const fn = pluginFn.default ?? pluginFn;
+    return pluginOpts != null ? fn(pluginOpts) : fn;
+  });
+}
+
 export function createPostcssPlugin(options: CreatePostcssPluginOptions): esbuild.Plugin {
   return {
     name: "sd-postcss",