@simplysm/sd-cli 14.0.88 → 14.0.90

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

@@ -1,31 +1,171 @@
-import consola from "consola";
+{{#if hasServer}}
+import { enableProdMode, inject, provideAppInitializer } from "@angular/core";
+{{else}}
 import { enableProdMode } from "@angular/core";
+{{/if}}
 import { bootstrapApplication } from "@angular/platform-browser";
 import { provideHttpClient, withFetch } from "@angular/common/http";
 {{#if client.hasRouter}}
 import { provideRouter, withHashLocation } from "@angular/router";
 {{/if}}
-import { provideSdAngular } from "@simplysm/angular";
-import { AppPage } from "./AppPage";
+import {
+  provideSdAngular,
+{{#if hasDb}}
+  SdSharedDataProvider,
+  SdSystemLogProvider,
+{{/if}}
+{{#if hasAuth}}
+  SdSystemConfigProvider,
+{{#if client.hasRouter}}
+  SdAppStructureProvider,
+{{/if}}
+{{/if}}
+} from "@simplysm/angular";
+import { createLogger{{#if hasDb}}, DateTime, json{{/if}} } from "@simplysm/core-common";
+{{#if hasAuth}}
+import { expr } from "@simplysm/orm-common";
+{{/if}}
+{{#if hasServer}}
+import {
+  AppServiceProvider,
+{{#if hasDb}}
+  AppOrmProvider,
+  AppSharedDataProvider,
+{{/if}}
+{{#if hasAuth}}
+  AppAuthProvider,
+{{/if}}
+} from "@{{workspaceName}}/client-common";
+{{/if}}
+{{#if hasAuth}}
+{{#if client.hasRouter}}
+import { {{client.appStructureName}} } from "@{{workspaceName}}/common";
+{{/if}}
+{{/if}}
+import { AppRoot } from "./app.root";
 {{#if client.hasRouter}}
 import { routes } from "./routes";
 {{/if}}
 import "./styles.scss";
 
+const CLIENT_NAME = "{{client.name}}";
+const logger = createLogger(CLIENT_NAME);
+
 if (typeof ngDevMode !== "undefined" && !ngDevMode) {
   enableProdMode();
 } else {
-  consola.log("dev mode");
+  logger.info("dev mode");
 }
 
-bootstrapApplication(AppPage, {
+bootstrapApplication(AppRoot, {
   providers: [
     provideHttpClient(withFetch()),
 {{#if client.hasRouter}}
     provideRouter(routes, withHashLocation()),
 {{/if}}
-    provideSdAngular({ clientName: "{{client.name}}" }),
+    provideSdAngular({ clientName: CLIENT_NAME }),
+{{#if hasDb}}
+
+    { provide: SdSharedDataProvider, useExisting: AppSharedDataProvider },
+{{/if}}
+{{#if hasServer}}
+
+    //-- app-service 연결
+    provideAppInitializer(async () => {
+      await inject(AppServiceProvider).connectAsync();
+    }),
+{{/if}}
+{{#if hasAuth}}
+{{#if client.hasRouter}}
+
+    //-- app-structure 초기화
+    provideAppInitializer(() => {
+      inject(SdAppStructureProvider).initialize({{client.appStructureName}});
+    }),
+{{/if}}
+{{/if}}
+{{#if hasDb}}
+
+    //-- 로그 DB 연동
+    provideAppInitializer(() => {
+      const sdSystemLog = inject(SdSystemLogProvider);
+      const appOrm = inject(AppOrmProvider);
+{{#if hasAuth}}
+      const appAuth = inject(AppAuthProvider);
+{{/if}}
+
+      sdSystemLog.writeFn = async (severity: "error" | "warn" | "log", ...logs: any[]) => {
+        await appOrm.connectAsync(async (db) => {
+          await db.systemLog().insert([
+            {
+              dateTime: new DateTime(),
+              severity,
+              message: logs
+                .map((l) =>
+                  typeof l === "string"
+                    ? l
+                    : l instanceof Error
+                      ? (l.stack ?? l.message)
+                      : json.stringify(l, { space: 2 }),
+                )
+                .join(" "),
+              clientName: CLIENT_NAME,
+{{#if hasAuth}}
+              {{userEntityCamel}}Id: appAuth.authInfo()?.{{userEntityCamel}}Id,
+{{/if}}
+            },
+          ]);
+        });
+      };
+    }),
+{{/if}}
+{{#if hasAuth}}
+
+    //-- 시스템 설정 DB 연동
+    provideAppInitializer(() => {
+      const sdSystemConfig = inject(SdSystemConfigProvider);
+      const appAuth = inject(AppAuthProvider);
+      const appOrm = inject(AppOrmProvider);
+
+      sdSystemConfig.fn = {
+        set: async (key: string, val: any) => {
+          const {{userEntityCamel}}Id = appAuth.authInfo()?.{{userEntityCamel}}Id;
+          if ({{userEntityCamel}}Id == null) return;
+
+          await appOrm.connectAsync(async (db) => {
+            await db
+              .{{userEntityCamel}}Config()
+              .where((item) => [expr.eq(item.{{userEntityCamel}}Id, {{userEntityCamel}}Id), expr.eq(item.code, key)])
+              .upsert(
+                () => ({
+                  valueJson: json.stringify(val),
+                }),
+                (updateRecord) => ({
+                  ...updateRecord,
+                  {{userEntityCamel}}Id,
+                  code: key,
+                }),
+              );
+          });
+        },
+        get: async (key: string) => {
+          const {{userEntityCamel}}Id = appAuth.authInfo()?.{{userEntityCamel}}Id;
+          if ({{userEntityCamel}}Id == null) return;
+
+          return appOrm.connectAsync(async (db) => {
+            const {{userEntityCamel}}Config = await db
+              .{{userEntityCamel}}Config()
+              .where((item) => [expr.eq(item.{{userEntityCamel}}Id, {{userEntityCamel}}Id), expr.eq(item.code, key)])
+              .single();
+            return {{userEntityCamel}}Config?.valueJson != null
+              ? json.parse({{userEntityCamel}}Config.valueJson)
+              : undefined;
+          });
+        },
+      };
+    }),
+{{/if}}
   ],
 }).catch((err: unknown) => {
-  consola.error(err);
+  logger.error("부트스트랩 실패", err);
 });

package/src/commands/init/templates/client/src/modals/dev.modal.ts.hbs

@@ -0,0 +1,63 @@
+import {
+  ChangeDetectionStrategy,
+  Component,
+  inject,
+  output,
+  signal,
+  ViewEncapsulation,
+} from "@angular/core";
+import {
+  SdBusyContainer,
+  SdButton,
+  type SdModalContentDef,
+  SdToastProvider,
+} from "@simplysm/angular";
+import { NgIcon } from "@ng-icons/core";
+import { tablerDatabase, tablerRefresh } from "@ng-icons/tabler-icons";
+import { AppServiceProvider } from "@{{workspaceName}}/client-common";
+
+@Component({
+  selector: "app-dev-modal",
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.None,
+  standalone: true,
+  imports: [SdBusyContainer, SdButton, NgIcon],
+  template: `
+    <sd-busy-container [busy]="busyCount() > 0">
+      <div class="p-default flex-column gap-sm">
+        <div class="flex-row gap-sm">
+          <sd-button (click)="onInitDbButtonClick()"><ng-icon [svg]="tablerDatabase" /> DB 초기화</sd-button>
+        </div>
+        <div class="flex-row gap-sm">
+          <sd-button [theme]="'gray'" (click)="onRefreshButtonClick()"><ng-icon [svg]="tablerRefresh" /> 새로고침</sd-button>
+        </div>
+      </div>
+    </sd-busy-container>
+  `,
+})
+export class DevModal implements SdModalContentDef<void> {
+  private readonly _sdToast = inject(SdToastProvider);
+  private readonly _appService = inject(AppServiceProvider);
+
+  initialized = signal(true);
+  busyCount = signal(0);
+
+  close = output<void | undefined>();
+
+  async onInitDbButtonClick() {
+    if (this.busyCount() > 0) return;
+    this.busyCount.update((v) => v + 1);
+    await this._sdToast.try(async () => {
+      await this._appService.dev.initDb();
+      this._sdToast.success("DB 초기화가 완료되었습니다.");
+    });
+    this.busyCount.update((v) => v - 1);
+  }
+
+  onRefreshButtonClick() {
+    location.reload();
+  }
+
+  protected readonly tablerDatabase = tablerDatabase;
+  protected readonly tablerRefresh = tablerRefresh;
+}

package/src/commands/init/templates/client/src/routes.ts.hbs

@@ -0,0 +1,29 @@
+import type { Routes } from "@angular/router";
+
+{{#if hasAuth}}
+export const routes: Routes = [
+  { path: "", redirectTo: "/login", pathMatch: "full" },
+  {
+    path: "login",
+    loadComponent: () => import("./app/login/login.view").then((m) => m.LoginView),
+  },
+  {
+    path: "home",
+    loadComponent: () => import("./app/home/home.view").then((m) => m.HomeView),
+    children: [
+      { path: "", redirectTo: "main", pathMatch: "full" },
+      {
+        path: "main",
+        loadComponent: () => import("./app/home/main/main.view").then((m) => m.MainView),
+      },
+      {
+        path: "my-info",
+        loadComponent: () =>
+          import("./app/home/my-info/my-info.detail").then((m) => m.MyInfoDetail),
+      },
+    ],
+  },
+];
+{{else}}
+export const routes: Routes = [];
+{{/if}}

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

@@ -11,6 +11,7 @@
     "@{{workspaceName}}/common": "workspace:*",
     "@simplysm/service-client": "^14.0.0",
     "@simplysm/service-common": "^14.0.0"{{/if}}{{#if hasDb}},
+    "@{{workspaceName}}/server": "workspace:*",
     "@simplysm/orm-common": "^14.0.0"{{/if}}
   },
   "devDependencies": {

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

@@ -1,8 +1,12 @@
 {{#if hasServer}}
-export { AppServiceProvider, APP_MAIN_SERVICE_KEY } from "./providers/AppServiceProvider";
+export * from "./providers/app-service.provider";
 {{/if}}
 {{#if hasDb}}
-export { AppOrmProvider } from "./providers/AppOrmProvider";
+export * from "./providers/app-orm.provider";
+export * from "./providers/app-shared-data.provider";
+{{/if}}
+{{#if hasAuth}}
+export * from "./providers/app-auth.provider";
 {{/if}}
 {{#unless hasServer}}
 {{#unless hasDb}}

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

@@ -0,0 +1,90 @@
+import { inject, Injectable, signal } from "@angular/core";
+import { SdAppStructureProvider, SdLocalStorageProvider } from "@simplysm/angular";
+import { createLogger } from "@simplysm/core-common";
+import type { IAuthData } from "@{{workspaceName}}/server";
+import { AppServiceProvider } from "./app-service.provider";
+import { AppSharedDataProvider } from "./app-shared-data.provider";
+
+const logger = createLogger("client-common:auth");
+
+interface IAppLocalStorageMap {
+  "auth-token": string;
+  "last-login-id": string;
+}
+
+@Injectable({ providedIn: "root" })
+export class AppAuthProvider {
+  private readonly _appService = inject(AppServiceProvider);
+  private readonly _sdLocalStorage = inject(
+    SdLocalStorageProvider,
+  ) as SdLocalStorageProvider<IAppLocalStorageMap>;
+  private readonly _sdAppStructure = inject(SdAppStructureProvider);
+  private readonly _appSharedData = inject(AppSharedDataProvider);
+
+  authInfo = signal<IAuthData | undefined>(undefined);
+
+  private _authEventKey?: string;
+
+  async login(loginId: string, password: string): Promise<void> {
+    const { token, ...authData } = await this._appService.auth.login(loginId, password);
+    this._sdLocalStorage.set("last-login-id", loginId);
+    await this._applyAuthAsync(token, authData);
+  }
+
+  async logout(): Promise<void> {
+    await this._clearAuthAsync();
+  }
+
+  async tryReloadAuth(): Promise<boolean> {
+    const currentToken = this._sdLocalStorage.get("auth-token");
+    if (currentToken == null || currentToken === "") return false;
+
+    try {
+      await this._appService.client.auth(currentToken);
+      const { token, ...authData } = await this._appService.auth.refresh();
+      await this._applyAuthAsync(token, authData);
+      return true;
+    } catch (err) {
+      logger.error("인증 재로드 실패", err);
+      await this._clearAuthAsync();
+      return false;
+    }
+  }
+
+  private async _applyAuthAsync(token: string, authData: IAuthData): Promise<void> {
+    this._sdLocalStorage.set("auth-token", token);
+    await this._appService.client.auth(token);
+    this.authInfo.set(authData);
+    this._sdAppStructure.permRecord.set(authData.permissions);
+    await this._registerAuthEvent(authData.{{userEntityCamel}}Id);
+    this._appSharedData.initialize();
+  }
+
+  private async _clearAuthAsync(): Promise<void> {
+    await this._unregisterAuthEvent();
+    this._sdLocalStorage.remove("auth-token");
+    this.authInfo.set(undefined);
+    this._sdAppStructure.permRecord.set(undefined);
+  }
+
+  private async _registerAuthEvent({{userEntityCamel}}Id: number): Promise<void> {
+    await this._unregisterAuthEvent();
+    this._authEventKey = await this._appService.authInfoChangedEvent.addListener(
+      { {{userEntityCamel}}Id },
+      async () => {
+        await this.tryReloadAuth();
+      },
+    );
+  }
+
+  private async _unregisterAuthEvent(): Promise<void> {
+    if (this._authEventKey != null) {
+      await this._appService.client.removeListener(this._authEventKey);
+      this._authEventKey = undefined;
+    }
+  }
+
+  getLastLoginId(): string | undefined {
+    return this._sdLocalStorage.get("last-login-id");
+  }
+}

package/src/commands/init/templates/client-common/src/providers/{AppOrmProvider.ts.hbs → app-orm.provider.ts.hbs}

@@ -1,34 +1,28 @@
 import { inject, Injectable } from "@angular/core";
-import { createOrmClientConnector, type OrmClientConnector } from "@simplysm/service-client";
 import { {{dbContextClassName}} } from "@{{workspaceName}}/common";
-import { AppServiceProvider } from "./AppServiceProvider";
+import { AppServiceProvider } from "./app-service.provider";
 
 @Injectable({ providedIn: "root" })
 export class AppOrmProvider {
   private readonly _appService = inject(AppServiceProvider);
 
-  private _orm?: OrmClientConnector;
-  private get orm(): OrmClientConnector {
-    return (this._orm ??= createOrmClientConnector(this._appService.client));
-  }
-
   connectAsync<R>(callback: (db: {{dbContextClassName}}) => Promise<R>): Promise<R> {
-    return this.orm.connect(
+    return this._appService.orm.connect(
       {
         DbClass: {{dbContextClassName}},
         connOpt: { configName: "{{dbContextNameUpper}}" },
-        dbContextOpt: { database: "{{workspaceNameUpper}}", schema: "dbo" },
+        dbContextOpt: { database: "{{workspaceNameUpper}}" },
       },
       callback,
     );
   }
 
   connectWithoutTransAsync<R>(callback: (db: {{dbContextClassName}}) => Promise<R>): Promise<R> {
-    return this.orm.connectWithoutTransaction(
+    return this._appService.orm.connectWithoutTransaction(
       {
         DbClass: {{dbContextClassName}},
         connOpt: { configName: "{{dbContextNameUpper}}" },
-        dbContextOpt: { database: "{{workspaceNameUpper}}", schema: "dbo" },
+        dbContextOpt: { database: "{{workspaceNameUpper}}" },
       },
       callback,
     );

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

@@ -0,0 +1,68 @@
+import { inject, Injectable } from "@angular/core";
+import { SdServiceClientFactoryProvider } from "@simplysm/angular";
+import { env, num, parseBoolEnv } from "@simplysm/core-common";
+{{#if hasDb}}
+import {
+  createOrmClientConnector,
+  type OrmClientConnector,
+  type ServiceProxy,
+{{#if hasAuth}}
+  type ClientEventProxy,
+{{/if}}
+} 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}}
+
+export const APP_MAIN_SERVICE_KEY = "MAIN";
+
+@Injectable({ providedIn: "root" })
+export class AppServiceProvider {
+  private readonly _sdServiceClientFactory = inject(SdServiceClientFactoryProvider);
+
+  get client() {
+    return this._sdServiceClientFactory.get(APP_MAIN_SERVICE_KEY);
+  }
+{{#if hasDb}}
+
+  private _orm?: OrmClientConnector;
+  get orm(): OrmClientConnector {
+    return (this._orm ??= createOrmClientConnector(this.client));
+  }
+
+  private _dev?: ServiceProxy<DevServiceMethods>;
+  get dev(): ServiceProxy<DevServiceMethods> {
+    return (this._dev ??= this.client.getService<DevServiceMethods>("DevService"));
+  }
+{{/if}}
+{{#if hasAuth}}
+
+  private _auth?: ServiceProxy<AuthServiceMethods>;
+  get auth(): ServiceProxy<AuthServiceMethods> {
+    return (this._auth ??= this.client.getService<AuthServiceMethods>("AuthService"));
+  }
+
+  private _authInfoChangedEvent?: ClientEventProxy<typeof AuthInfoChangedEvent>;
+  get authInfoChangedEvent(): ClientEventProxy<typeof AuthInfoChangedEvent> {
+    return (this._authInfoChangedEvent ??= this.client.getEvent(AuthInfoChangedEvent));
+  }
+{{/if}}
+
+  async connectAsync() {
+    await this._sdServiceClientFactory.connectAsync(
+      APP_MAIN_SERVICE_KEY,
+      Boolean(env("SERVER_HOST"))
+        ? {
+            host: env("SERVER_HOST"),
+            port: num.parseInt(env("SERVER_PORT")),
+            ssl: parseBoolEnv(env("SERVER_SSL")),
+          }
+        : {},
+    );
+  }
+}

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

@@ -0,0 +1,100 @@
+import { inject, Injectable } from "@angular/core";
+import {
+  SdSharedDataProvider,
+{{#if hasAuth}}
+  type SharedDataBase,
+{{/if}}
+  type SharedDataHandle,
+} from "@simplysm/angular";
+{{#if hasAuth}}
+import { expr } from "@simplysm/orm-common";
+import { AppOrmProvider } from "./app-orm.provider";
+{{/if}}
+
+export function useSharedSignal<K extends keyof TAppSharedData>(
+  name: K,
+): SharedDataHandle<TAppSharedData[K]> {
+  const appSharedData = inject(AppSharedDataProvider);
+  return appSharedData.getHandle(name);
+}
+
+@Injectable({ providedIn: "root" })
+export class AppSharedDataProvider extends SdSharedDataProvider<TAppSharedData> {
+{{#if hasAuth}}
+  private readonly _appOrm = inject(AppOrmProvider);
+
+{{/if}}
+  override initialize() {
+{{#if hasAuth}}
+    this.register("{{userEntityLabel}}", {
+      serviceKey: "{{dbContextNameUpper}}",
+      getter: async (changeKeys) => {
+        return this._appOrm.connectAsync(async (db) => {
+          let qr = db.{{userEntityCamel}}().select((item) => ({
+            id: item.id,
+            name: item.name,
+            isDeleted: item.isDeleted,
+
+            __valueKey: item.id,
+            __searchText: item.name,
+            __isHidden: item.isDeleted,
+          }));
+
+          if (changeKeys) {
+            qr = qr.where((item) => [expr.in(item.id, changeKeys as number[])]);
+          }
+          return qr.execute();
+        });
+      },
+      orderBy: (item) => item.name,
+    });
+
+    this.register("역할", {
+      serviceKey: "{{dbContextNameUpper}}",
+      getter: async (changeKeys) => {
+        return this._appOrm.connectAsync(async (db) => {
+          let qr = db.role().select((item) => ({
+            id: item.id,
+            name: item.name,
+            isDeleted: item.isDeleted,
+
+            __valueKey: item.id,
+            __searchText: item.name,
+            __isHidden: item.isDeleted,
+          }));
+
+          if (changeKeys) {
+            qr = qr.where((item) => [expr.in(item.id, changeKeys as number[])]);
+          }
+          return qr.execute();
+        });
+      },
+      orderBy: (item) => item.name,
+    });
+{{else}}
+    // TODO: 공유 데이터 등록
+    // this.register("키", { serviceKey: "{{dbContextNameUpper}}", getter: async () => [...], orderBy: (item) => item.name });
+{{/if}}
+  }
+}
+
+{{#if hasAuth}}
+export type TAppSharedData = {
+  {{userEntityLabel}}: IShared{{userEntityPascal}};
+  역할: ISharedRole;
+};
+
+export interface IShared{{userEntityPascal}} extends SharedDataBase<number> {
+  id: number;
+  name: string;
+  isDeleted: boolean;
+}
+
+export interface ISharedRole extends SharedDataBase<number> {
+  id: number;
+  name: string;
+  isDeleted: boolean;
+}
+{{else}}
+export type TAppSharedData = {};
+{{/if}}

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

@@ -5,6 +5,7 @@
   "private": true,
   "dependencies": {
     "@simplysm/core-common": "^14.0.0"{{#if hasDb}},
-    "@simplysm/orm-common": "^14.0.0"{{/if}}
+    "@simplysm/orm-common": "^14.0.0"{{/if}}{{#if hasAuth}},
+    "@simplysm/service-common": "^14.0.0"{{/if}}
   }
 }

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

@@ -0,0 +1,26 @@
+import type { AppStructureItem } from "@simplysm/service-common";
+
+{{#each appStructureNames}}
+export const {{this}}: AppStructureItem[] = [
+  { title: "메인화면", code: "main", isNotMenu: true },
+  { title: "내 정보 수정", code: "my-info", isNotMenu: true },
+
+  {
+    code: "base",
+    title: "기준정보",
+    children: [
+      { code: "role-permission", title: "역할/권한", perms: ["use", "edit"] },
+      { code: "{{../userEntityKebab}}", title: "{{../userEntityLabel}}", perms: ["use", "edit"] },
+    ],
+  },
+  {
+    code: "system",
+    title: "시스템",
+    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

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

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

@@ -0,0 +1,20 @@
+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 { RolePermission } from "./tables/system/role-permission";
+{{/if}}
+import { SystemDataLog } from "./tables/system/system-data-log";
+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);
+  rolePermission = this.queryable(RolePermission);
+{{/if}}
+  dataLog = this.queryable(SystemDataLog);
+  systemLog = this.queryable(SystemLog);
+}