sonamu 0.0.42 → 0.1.0

package/src/index.ts

@@ -7,9 +7,9 @@ export * from "./database/db";
 export * from "./database/upsert-builder";
 export * from "./exceptions/error-handler";
 export * from "./exceptions/so-exceptions";
-export * from "./smd/smd-manager";
-export * from "./smd/smd-utils";
-export * from "./smd/migrator";
+export * from "./entity/entity-manager";
+export * from "./entity/entity-utils";
+export * from "./entity/migrator";
 export * from "./syncer/syncer";
 export * from "./testing/fixture-manager";
 export * from "./types/types";

package/src/smd/smd-manager.ts

@@ -6,18 +6,8 @@ import path from "path";
 import { SMD } from "./smd";
 import { SMDInput } from "../types/types";
 import { Sonamu } from "../api/sonamu";
+import { EntityNamesRecord } from "../entity/entity-manager";
 
-export type SMDNamesRecord = Record<
-  | "fs"
-  | "fsPlural"
-  | "camel"
-  | "camelPlural"
-  | "capital"
-  | "capitalPlural"
-  | "upper"
-  | "constant",
-  string
->;
 type TableSpec = {
   name: string;
   uniqueColumns: string[];
@@ -124,8 +114,8 @@ class SMDManagerClass {
     return tableSpec;
   }
 
-  getNamesFromId(smdId: string): SMDNamesRecord {
-    // smdId가 단복수 동형 단어인 경우 List 붙여서 생성
+  getNamesFromId(smdId: string): EntityNamesRecord {
+    // entityId가 단복수 동형 단어인 경우 List 붙여서 생성
     const pluralized =
       pluralize(smdId) === smdId ? `${smdId}List` : pluralize(smdId);
 

package/src/smd/smd.ts

@@ -1,10 +1,8 @@
 import _, { uniq } from "lodash";
-import { SMDManager } from "./smd-manager";
 import { dasherize, pluralize, underscore } from "inflection";
 import {
-  SMDProp,
+  EntityProp,
   RelationProp,
-  SMDInput,
   isRelationProp,
   SubsetQuery,
   isVirtualProp,
@@ -12,17 +10,19 @@ import {
   isOneToOneRelationProp,
   isHasManyRelationProp,
   isManyToManyRelationProp,
-  SMDPropNode,
+  EntityPropNode,
   isEnumProp,
   StringProp,
-  SMDIndex,
+  EntityIndex,
+  EnumsLabelKo,
+  SMDInput,
 } from "../types/types";
 import inflection from "inflection";
 import path from "path";
 import { existsSync } from "fs";
 import { z } from "zod";
-import { EnumsLabelKo } from "../types/types";
 import { Sonamu } from "../api/sonamu";
+import { SMDManager } from "./smd-manager";
 
 export class SMD {
   id: string;
@@ -33,14 +33,14 @@ export class SMD {
     fs: string;
     module: string;
   };
-  props: SMDProp[];
+  props: EntityProp[];
   propsDict: {
-    [key: string]: SMDProp;
+    [key: string]: EntityProp;
   };
   relations: {
     [key: string]: RelationProp;
   };
-  indexes: SMDIndex[];
+  indexes: EntityIndex[];
   subsets: {
     [key: string]: string[];
   };
@@ -355,7 +355,10 @@ export class SMD {
   /*
     FieldExpr[] 을 SMDPropNode[] 로 변환
   */
-  fieldExprsToPropNodes(fieldExprs: string[], smd: SMD = this): SMDPropNode[] {
+  fieldExprsToPropNodes(
+    fieldExprs: string[],
+    smd: SMD = this
+  ): EntityPropNode[] {
     const groups = fieldExprs.reduce(
       (result, fieldExpr) => {
         let key, value, elseExpr;

package/src/syncer/syncer.ts

@@ -13,7 +13,7 @@ import crypto from "crypto";
 import equal from "fast-deep-equal";
 import { differenceWith, groupBy, isEqual, uniq } from "lodash";
 import { camelize } from "inflection";
-import { SMDManager } from "../smd/smd-manager";
+import { EntityManager } from "../entity/entity-manager";
 import * as ts from "typescript";
 import {
   ApiParam,
@@ -37,8 +37,8 @@ import {
   isTimestampProp,
   isUuidProp,
   isVirtualProp,
-  SMDProp,
-  SMDPropNode,
+  EntityProp,
+  EntityPropNode,
   SQLDateTimeString,
 } from "../types/types";
 import {
@@ -64,10 +64,8 @@ import { wrapIf } from "../utils/lodash-able";
 import { getTextTypeLength } from "../api/code-converters";
 import { Template } from "../templates/base-template";
 import { Template__generated } from "../templates/generated.template";
-import { Template__init_enums } from "../templates/init_enums.template";
-import { Template__init_generated } from "../templates/init_generated.template";
 import { Template__init_types } from "../templates/init_types.template";
-import { Template__smd } from "../templates/smd.template";
+import { Template__entity } from "../templates/entity.template";
 import { Template__model } from "../templates/model.template";
 import { Template__model_test } from "../templates/model_test.template";
 import { Template__service } from "../templates/service.template";
@@ -83,8 +81,9 @@ import { Template__view_search_input } from "../templates/view_search_input.temp
 import { Template__view_list_columns } from "../templates/view_list_columns.template";
 import { Template__generated_http } from "../templates/generated_http.template";
 import { Sonamu } from "../api/sonamu";
+import { execSync } from "child_process";
 
-type FileType = "model" | "types" | "enums" | "smd" | "generated";
+type FileType = "model" | "types" | "functions" | "generated" | "entity";
 type GlobPattern = {
   [key in FileType]: string;
 };
@@ -182,33 +181,35 @@ export class Syncer {
 
     // 다른 부분 찾아 액션
     const diffGroups = groupBy(diffFiles, (r) => {
-      const matched = r.match(/\.(model|types|enums|smd|generated)\.[tj]s/);
+      const matched = r.match(
+        /\.(model|types|functions|entity|generated)\.[tj]s/
+      );
       return matched![1];
     }) as unknown as DiffGroups;
 
     // 변경된 파일들을 타입별로 분리하여 각 타입별 액션 처리
     const diffTypes = Object.keys(diffGroups);
 
-    // 트리거: smd
+    // 트리거: entity
     // 액션: 스키마 생성
-    if (diffTypes.includes("smd")) {
+    if (diffTypes.includes("entity")) {
       console.log("// 액션: 스키마 생성");
-      const smdIds = this.getSMDIdFromPath(diffGroups["smd"]);
-      await this.actionGenerateSchemas(smdIds);
+      const entityIds = this.getEntityIdFromPath(diffGroups["entity"]);
+      await this.actionGenerateSchemas(entityIds);
     }
 
     // 트리거: types, enums, generated 변경시
     // 액션: 파일 싱크 types, enums, generated
     if (
       diffTypes.includes("types") ||
-      diffTypes.includes("enums") ||
+      diffTypes.includes("functions") ||
       diffTypes.includes("generated")
     ) {
-      console.log("// 액션: 파일 싱크 types / enums / generated");
+      console.log("// 액션: 파일 싱크 types / functions / generated");
 
       const tsPaths = [
         ...(diffGroups["types"] ?? []),
-        ...(diffGroups["enums"] ?? []),
+        ...(diffGroups["functions"] ?? []),
         ...(diffGroups["generated"] ?? []),
       ].map((p) => p.replace("/dist/", "/src/").replace(".js", ".ts"));
       await this.actionSyncFilesToTargets(tsPaths);
@@ -216,32 +217,32 @@ export class Syncer {
 
     // 트리거: model
     if (diffTypes.includes("model")) {
-      const smdIds = this.getSMDIdFromPath(diffGroups["model"]);
+      const entityIds = this.getEntityIdFromPath(diffGroups["model"]);
       console.log("// 액션: 서비스 생성");
-      await this.actionGenerateServices(smdIds);
+      await this.actionGenerateServices(entityIds);
       console.log("// 액션: HTTP파일 생성");
-      await this.actionGenerateHttps(smdIds);
+      await this.actionGenerateHttps(entityIds);
     }
 
     // 저장
     await this.saveChecksums(currentChecksums);
   }
 
-  getSMDIdFromPath(filePaths: string[]): string[] {
+  getEntityIdFromPath(filePaths: string[]): string[] {
     return filePaths.map((p) => {
       const matched = p.match(/application\/(.+)\//);
       return camelize(matched![1].replace(/\-/g, "_"));
     });
   }
 
-  async actionGenerateSchemas(smdIds: string[]): Promise<string[]> {
+  async actionGenerateSchemas(entityIds: string[]): Promise<string[]> {
     return (
       await Promise.all(
-        smdIds.map(async (smdId) =>
+        entityIds.map(async (entityId) =>
           this.generateTemplate(
             "generated",
             {
-              smdId,
+              entityId,
             },
             {
               overwrite: true,
@@ -254,14 +255,14 @@ export class Syncer {
       .flat();
   }
 
-  async actionGenerateServices(smdIds: string[]): Promise<string[]> {
+  async actionGenerateServices(entityIds: string[]): Promise<string[]> {
     return (
       await Promise.all(
-        smdIds.map(async (smdId) =>
+        entityIds.map(async (entityId) =>
           this.generateTemplate(
             "service",
             {
-              smdId,
+              entityId,
             },
             {
               overwrite: true,
@@ -274,14 +275,14 @@ export class Syncer {
       .flat();
   }
 
-  async actionGenerateHttps(smdIds: string[]): Promise<string[]> {
+  async actionGenerateHttps(entityIds: string[]): Promise<string[]> {
     return (
       await Promise.all(
-        smdIds.map(async (smdId) =>
+        entityIds.map(async (entityId) =>
           this.generateTemplate(
             "generated_http",
             {
-              smdId,
+              entityId,
             },
             {
               overwrite: true,
@@ -342,13 +343,13 @@ export class Syncer {
 
   async getCurrentChecksums(): Promise<PathAndChecksum[]> {
     const PatternGroup: GlobPattern = {
-      /* TS 체크 */
+      /* 원본 체크 */
+      entity: Sonamu.apiRootPath + "/src/application/**/*.entity.json",
       types: Sonamu.apiRootPath + "/src/application/**/*.types.ts",
-      enums: Sonamu.apiRootPath + "/src/application/**/*.enums.ts",
       generated: Sonamu.apiRootPath + "/src/application/**/*.generated.ts",
+      functions: Sonamu.apiRootPath + "/src/application/**/*.functions.ts",
       /* compiled-JS 체크 */
       model: Sonamu.apiRootPath + "/dist/application/**/*.model.js",
-      smd: Sonamu.apiRootPath + "/dist/application/**/*.smd.js",
     };
 
     const filePaths = (
@@ -708,7 +709,6 @@ export class Syncer {
 
     const pathPatterns = [
       path.join(Sonamu.apiRootPath, "/dist/application/**/*.types.js"),
-      path.join(Sonamu.apiRootPath, "/dist/application/**/*.enums.js"),
       path.join(Sonamu.apiRootPath, "/dist/application/**/*.generated.js"),
     ];
     // console.debug(chalk.magenta(`autoload:types @ ${pathPatterns.join("\n")}`));
@@ -727,14 +727,10 @@ export class Syncer {
   }
 
   getTemplate(key: TemplateKey): Template {
-    if (key === "smd") {
-      return new Template__smd();
-    } else if (key === "init_enums") {
-      return new Template__init_enums();
+    if (key === "entity") {
+      return new Template__entity();
     } else if (key === "init_types") {
       return new Template__init_types();
-    } else if (key === "init_generated") {
-      return new Template__init_generated();
     } else if (key === "generated") {
       return new Template__generated();
     } else if (key === "generated_http") {
@@ -777,24 +773,24 @@ export class Syncer {
     let extra: unknown[] = [];
     if (key === "service" || key === "generated_http") {
       // service 필요 정보 (API 리스트)
-      const smd = SMDManager.get(options.smdId);
+      const entity = EntityManager.get(options.entityId);
       const modelTsPath = `${path.join(
         Sonamu.apiRootPath,
         "/src/application"
-      )}/${smd.names.fs}/${smd.names.fs}.model.ts`;
+      )}/${entity.names.fs}/${entity.names.fs}.model.ts`;
       extra = [await this.readApisFromFile(modelTsPath)];
     } else if (key === "view_list" || key === "model") {
       // view_list 필요 정보 (컬럼 노드, 리스트파라미터 노드)
-      const columnsNode = await this.getColumnsNode(options.smdId, "A");
+      const columnsNode = await this.getColumnsNode(options.entityId, "A");
       const listParamsZodType = await this.getZodTypeById(
-        `${options.smdId}ListParams`
+        `${options.entityId}ListParams`
       );
       const listParamsNode = this.zodTypeToRenderingNode(listParamsZodType);
       extra = [columnsNode, listParamsNode];
     } else if (key === "view_form") {
       // view_form 필요 정보 (세이브파라미터 노드)
       const saveParamsZodType = await this.getZodTypeById(
-        `${options.smdId}SaveParams`
+        `${options.entityId}SaveParams`
       );
       const saveParamsNode = this.zodTypeToRenderingNode(saveParamsZodType);
       extra = [saveParamsNode];
@@ -827,7 +823,7 @@ export class Syncer {
     const importDefs = importKeys
       .reduce(
         (r, importKey) => {
-          const modulePath = SMDManager.getModulePath(importKey);
+          const modulePath = EntityManager.getModulePath(importKey);
           let importPath = modulePath;
           if (modulePath.includes("/")) {
             importPath = wrapIf(
@@ -870,12 +866,15 @@ export class Syncer {
       ),
     ].join("\n");
 
-    const formatted =
-      key === "generated_http"
-        ? [header, body].join("\n\n")
-        : await prettier.format([header, body].join("\n\n"), {
-            parser: "typescript",
-          });
+    const formatted = await (async () => {
+      if (key === "generated_http") {
+        return [header, body].join("\n\n");
+      } else {
+        return await prettier.format([header, body].join("\n\n"), {
+          parser: key === "entity" ? "json" : "typescript",
+        });
+      }
+    })();
 
     return {
       path: target + "/" + filePath,
@@ -919,9 +918,9 @@ export class Syncer {
 
     // 키 children
     let keys: TemplateKey[] = [key];
-    if (key === "smd") {
-      keys = ["smd", "init_enums", "init_generated", "init_types"];
-    }
+    // if (key === "entity") {
+    //   keys = ["entity", "init_generated", "init_types"];
+    // }
 
     // 템플릿 렌더
     const pathAndCodes = (
@@ -972,13 +971,13 @@ export class Syncer {
   }
 
   checkExists(
-    smdId: string,
+    entityId: string,
     enums: {
       [name: string]: z.ZodEnum<any>;
     }
   ): Record<`${TemplateKey}${string}`, boolean> {
     const keys: TemplateKey[] = TemplateKey.options;
-    const names = SMDManager.getNamesFromId(smdId);
+    const names = EntityManager.getNamesFromId(entityId);
     const enumsKeys = Object.keys(enums).filter(
       (name) => name !== names.constant
     );
@@ -1012,7 +1011,7 @@ export class Syncer {
   }
 
   async getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny> {
-    const modulePath = SMDManager.getModulePath(zodTypeId);
+    const modulePath = EntityManager.getModulePath(zodTypeId);
     const moduleAbsPath = path.join(
       Sonamu.apiRootPath,
       "dist",
@@ -1028,7 +1027,7 @@ export class Syncer {
     return imported[zodTypeId].describe(zodTypeId);
   }
 
-  async propNodeToZodType(propNode: SMDPropNode): Promise<z.ZodTypeAny> {
+  async propNodeToZodType(propNode: EntityPropNode): Promise<z.ZodTypeAny> {
     if (propNode.nodeType === "plain") {
       return this.propToZodType(propNode.prop);
     } else if (propNode.nodeType === "array") {
@@ -1070,7 +1069,7 @@ export class Syncer {
       throw Error;
     }
   }
-  async propToZodType(prop: SMDProp): Promise<z.ZodTypeAny> {
+  async propToZodType(prop: EntityProp): Promise<z.ZodTypeAny> {
     let zodType: z.ZodTypeAny = z.unknown();
     if (isIntegerProp(prop)) {
       zodType = z.number().int();
@@ -1097,19 +1096,11 @@ export class Syncer {
     } else if (isTimestampProp(prop)) {
       zodType = SQLDateTimeString;
     } else if (isJsonProp(prop)) {
-      if (prop.as instanceof z.ZodType) {
-        zodType = prop.as;
-      } else {
-        zodType = await this.getZodTypeById(prop.as.ref);
-      }
+      zodType = await this.getZodTypeById(prop.id);
     } else if (isUuidProp(prop)) {
       zodType = z.string().uuid();
     } else if (isVirtualProp(prop)) {
-      if (prop.as instanceof z.ZodType) {
-        zodType = prop.as;
-      } else {
-        zodType = await this.getZodTypeById(prop.as.ref);
-      }
+      zodType = await this.getZodTypeById(prop.id);
     } else if (isRelationProp(prop)) {
       if (
         isBelongsToOneRelationProp(prop) ||
@@ -1226,14 +1217,14 @@ export class Syncer {
     }
   }
 
-  async getColumnsNode(smdId: string, subsetKey: string) {
-    const smd = await SMDManager.get(smdId);
-    const subsetA = smd.subsets[subsetKey];
+  async getColumnsNode(entityId: string, subsetKey: string) {
+    const entity = await EntityManager.get(entityId);
+    const subsetA = entity.subsets[subsetKey];
     if (subsetA === undefined) {
       throw new ServiceUnavailableException("SubsetA 가 없습니다.");
     }
-    const propNodes = smd.fieldExprsToPropNodes(subsetA);
-    const rootPropNode: SMDPropNode = {
+    const propNodes = entity.fieldExprsToPropNodes(subsetA);
+    const rootPropNode: EntityPropNode = {
       nodeType: "object",
       children: propNodes,
     };
@@ -1287,4 +1278,65 @@ export class Syncer {
 
     return columnsNode;
   }
+
+  async createEntity(
+    entityId: string,
+    parentId?: string,
+    table?: string,
+    title?: string
+  ) {
+    await this.generateTemplate("entity", {
+      entityId,
+      parentId,
+      table,
+      title,
+    });
+
+    // reload entities
+    await EntityManager.reload();
+
+    // generate schemas
+    await this.actionGenerateSchemas([entityId]);
+
+    // generate types
+    await this.generateTemplate("init_types", {
+      entityId,
+    });
+  }
+
+  async delEntity(entityId: string): Promise<{ delPaths: string[] }> {
+    const entity = EntityManager.get(entityId);
+
+    const delPaths = (() => {
+      if (entity.parentId) {
+        return [
+          `${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`,
+        ];
+      } else {
+        return [
+          `${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
+          `${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
+          ...Sonamu.config.sync.targets
+            .map((target) => [
+              `${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`,
+            ])
+            .flat(),
+        ];
+      }
+    })(); // iife
+
+    for await (const delPath of delPaths) {
+      if (existsSync(delPath)) {
+        console.log(chalk.red(`DELETE ${delPath}`));
+        execSync(`rm -rf ${delPath}`);
+      } else {
+        console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
+      }
+    }
+
+    // reload entities
+    await EntityManager.reload();
+
+    return { delPaths };
+  }
 }

package/src/templates/base-template.ts

@@ -1,5 +1,5 @@
 import { TemplateKey, TemplateOptions } from "../types/types";
-import { SMDNamesRecord } from "../smd/smd-manager";
+import { EntityNamesRecord } from "../entity/entity-manager";
 import { RenderedTemplate } from "../syncer/syncer";
 
 export abstract class Template {
@@ -10,7 +10,7 @@ export abstract class Template {
   ): RenderedTemplate;
 
   public abstract getTargetAndPath(
-    names: SMDNamesRecord,
+    names: EntityNamesRecord,
     ...extra: unknown[]
   ): {
     target: string;

package/src/templates/entity.template.ts

@@ -0,0 +1,50 @@
+import { TemplateOptions } from "../types/types";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
+import { Template } from "./base-template";
+
+export class Template__entity extends Template {
+  constructor() {
+    super("entity");
+  }
+
+  getTargetAndPath(names: EntityNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.entity.json`,
+    };
+  }
+
+  render(options: TemplateOptions["entity"]) {
+    const { entityId, title, parentId, table } = options;
+    const names = EntityManager.getNamesFromId(entityId);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: JSON.stringify({
+        id: entityId,
+        title: title ?? entityId,
+        parentId,
+        table: table ?? names.fsPlural.replace(/\-/g, "_"),
+        props: [
+          { name: "id", type: "integer", unsigned: true },
+          {
+            name: "created_at",
+            type: "timestamp",
+            dbDefault: "CURRENT_TIMESTAMP",
+          },
+        ],
+        indexes: [],
+        subsets: {
+          A: ["id", "created_at"],
+        },
+        enums: {
+          [`${names.capital}OrderBy`]: {
+            "id-desc": "ID최신순",
+          },
+          [`${names.capital}SearchField`]: { id: "ID" },
+        },
+      }).trim(),
+      importKeys: [],
+    };
+  }
+}