sonamu 0.4.13 → 0.5.0

package/src/smd/smd-manager.ts

@@ -1,139 +0,0 @@
-import chalk from "chalk";
-import glob from "glob";
-import inflection from "inflection";
-import _ from "lodash";
-import path from "path";
-import { SMD } from "./smd";
-import { SMDInput } from "../types/types";
-import { Sonamu } from "../api/sonamu";
-import { EntityNamesRecord } from "../entity/entity-manager";
-
-type TableSpec = {
-  name: string;
-  uniqueColumns: string[];
-};
-class SMDManagerClass {
-  private SMDs: Map<string, SMD> = new Map();
-  public modulePaths: Map<string, string> = new Map();
-  private tableSpecs: Map<string, TableSpec> = new Map();
-  public isAutoloaded: boolean = false;
-
-  // 경로 전달받아 모든 SMD 파일 로드
-  async autoload(doSilent: boolean = false) {
-    if (this.isAutoloaded) {
-      return;
-    }
-    const pathPattern = path.join(
-      Sonamu.apiRootPath,
-      "/dist/application/**/*.smd.js"
-    );
-    !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
-
-    return new Promise((resolve) => {
-      glob.glob(path.resolve(pathPattern!), (_err, files) => {
-        const importPaths = files.map((filePath) =>
-          path.relative(__dirname, filePath)
-        );
-        Promise.all(
-          importPaths.map(async (importPath) => {
-            const imported = await import(importPath);
-            Object.values(imported).map((smdInput) =>
-              this.register(smdInput as SMDInput<string>)
-            );
-            return imported;
-          })
-        ).then(() => {
-          resolve("ok");
-          this.isAutoloaded = true;
-        });
-      });
-    });
-  }
-
-  register(smdInput: SMDInput<string>): void {
-    const smd = new SMD(smdInput);
-    this.SMDs.set(smdInput.id, smd);
-  }
-
-  get(smdId: string): SMD {
-    const smd = this.SMDs.get(smdId);
-    if (smd === undefined) {
-      throw new Error(`존재하지 않는 SMD 요청 ${smdId}`);
-    }
-
-    return smd;
-  }
-
-  exists(smdId: string): boolean {
-    const smd = this.SMDs.get(smdId);
-    return smd !== undefined;
-  }
-
-  getAllIds(): string[] {
-    return Array.from(SMDManager.SMDs.keys());
-  }
-
-  getAllParentIds(): string[] {
-    return this.getAllIds().filter((smdId) => {
-      const smd = this.get(smdId);
-      return smd.parentId === undefined;
-    });
-  }
-
-  getChildrenIds(parentId: string): string[] {
-    return this.getAllIds().filter((smdId) => {
-      const smd = this.get(smdId);
-      return smd.parentId === parentId;
-    });
-  }
-
-  setModulePath(key: string, modulePath: string): void {
-    // console.debug(chalk.cyan(`setModulePath :: ${key} :: ${modulePath}`));
-    this.modulePaths.set(key, modulePath);
-  }
-
-  getModulePath(key: string): string {
-    const modulePath = this.modulePaths.get(key);
-    if (modulePath === undefined) {
-      throw new Error(`존재하지 않는 모듈 패스 요청 ${key}`);
-    }
-
-    return modulePath;
-  }
-
-  setTableSpec(tableSpec: TableSpec) {
-    this.tableSpecs.set(tableSpec.name, tableSpec);
-  }
-
-  getTableSpec(key: string): TableSpec {
-    const tableSpec = this.tableSpecs.get(key);
-    if (tableSpec === undefined) {
-      throw new Error(`존재하지 않는 테이블 스펙 요청 ${key}`);
-    }
-
-    return tableSpec;
-  }
-
-  getNamesFromId(smdId: string): EntityNamesRecord {
-    // entityId가 단복수 동형 단어인 경우 List 붙여서 생성
-    const pluralized =
-      inflection.pluralize(smdId) === smdId
-        ? `${smdId}List`
-        : inflection.pluralize(smdId);
-
-    return {
-      fs: inflection.dasherize(inflection.underscore(smdId)).toLowerCase(),
-      fsPlural: inflection
-        .dasherize(inflection.underscore(pluralized))
-        .toLowerCase(),
-      camel: inflection.camelize(smdId, true),
-      camelPlural: inflection.camelize(pluralized, true),
-      capital: smdId,
-      capitalPlural: pluralized,
-      upper: smdId.toUpperCase(),
-      constant: inflection.underscore(smdId).toUpperCase(),
-    };
-  }
-}
-
-export const SMDManager = new SMDManagerClass();

package/src/smd/smd.ts

@@ -1,571 +0,0 @@
-import _ from "lodash";
-import {
-  EntityProp,
-  RelationProp,
-  isRelationProp,
-  SubsetQuery,
-  isVirtualProp,
-  isBelongsToOneRelationProp,
-  isOneToOneRelationProp,
-  isHasManyRelationProp,
-  isManyToManyRelationProp,
-  EntityPropNode,
-  isEnumProp,
-  StringProp,
-  EntityIndex,
-  EnumsLabelKo,
-  SMDInput,
-} from "../types/types";
-import inflection from "inflection";
-import path from "path";
-import fs from "fs-extra";
-import { z } from "zod";
-import { Sonamu } from "../api/sonamu";
-import { SMDManager } from "./smd-manager";
-
-export class SMD {
-  id: string;
-  parentId?: string;
-  table: string;
-  title: string;
-  names: {
-    fs: string;
-    module: string;
-  };
-  props: EntityProp[];
-  propsDict: {
-    [key: string]: EntityProp;
-  };
-  relations: {
-    [key: string]: RelationProp;
-  };
-  indexes: EntityIndex[];
-  subsets: {
-    [key: string]: string[];
-  };
-  types: {
-    [name: string]: z.ZodTypeAny;
-  } = {};
-  enums: {
-    [name: string]: z.ZodEnum<any>;
-  } = {};
-  enumLabels: {
-    [name: string]: EnumsLabelKo<string>;
-  } = {};
-
-  constructor({
-    id,
-    parentId,
-    table,
-    title,
-    props,
-    indexes,
-    subsets,
-  }: SMDInput<any>) {
-    // id
-    this.id = id;
-    this.parentId = parentId;
-    this.title = title ?? this.id;
-    this.table = table ?? inflection.underscore(inflection.pluralize(id));
-
-    // props
-    if (props) {
-      this.props = props.map((prop) => {
-        if (isEnumProp(prop)) {
-          if (prop.id.includes("$Model")) {
-            prop.id = prop.id.replace("$Model", id);
-          }
-        }
-        return prop;
-      });
-      this.propsDict = props.reduce((result, prop) => {
-        return {
-          ...result,
-          [prop.name]: prop,
-        };
-      }, {});
-
-      // relations
-      this.relations = props
-        .filter((prop) => isRelationProp(prop))
-        .reduce((result, prop) => {
-          return {
-            ...result,
-            [prop.name]: prop,
-          };
-        }, {});
-    } else {
-      this.props = [];
-      this.propsDict = {};
-      this.relations = {};
-    }
-
-    // indexes
-    this.indexes = indexes ?? [];
-
-    // subsets
-    this.subsets = subsets ?? {};
-
-    // names
-    this.names = {
-      fs:
-        parentId === undefined
-          ? inflection.dasherize(inflection.underscore(id)).toLowerCase()
-          : inflection.dasherize(parentId).toLowerCase(),
-      module: id,
-    };
-
-    this.registerModulePaths();
-    this.registerTableSpecs();
-  }
-
-  /*
-    subset SELECT/JOIN/LOADER 결과 리턴
-  */
-  getSubsetQuery(subsetKey: string): SubsetQuery {
-    const subset = this.subsets[subsetKey];
-
-    const result: SubsetQuery = this.resolveSubsetQuery("", subset);
-    return result;
-  }
-
-  /*
-   */
-  resolveSubsetQuery(
-    prefix: string,
-    fields: string[],
-    isAlreadyOuterJoined: boolean = false
-  ): SubsetQuery {
-    // prefix 치환 (prefix는 ToOneRelation이 복수로 붙은 경우 모두 __로 변경됨)
-    prefix = prefix.replace(/\./g, "__");
-
-    // 서브셋을 1뎁스만 분리하여 그룹핑
-    const subsetGroup = _.groupBy(fields, (field) => {
-      if (field.includes(".")) {
-        const [rel] = field.split(".");
-        return rel;
-      } else {
-        return "";
-      }
-    });
-
-    const result = Object.keys(subsetGroup).reduce(
-      (r, groupKey) => {
-        const fields = subsetGroup[groupKey];
-        // 현재 테이블 필드셋은 select, virtual에 추가하고 리턴
-        if (groupKey === "") {
-          const realFields = fields.filter(
-            (field) => !isVirtualProp(this.propsDict[field])
-          );
-          const virtualFields = fields.filter((field) =>
-            isVirtualProp(this.propsDict[field])
-          );
-
-          if (prefix === "") {
-            // 현재 테이블인 경우
-            r.select = r.select.concat(
-              realFields.map((field) => `${this.table}.${field}`)
-            );
-            r.virtual = r.virtual.concat(virtualFields);
-          } else {
-            // 넘어온 테이블인 경우
-            r.select = r.select.concat(
-              realFields.map(
-                (field) => `${prefix}.${field} as ${prefix}__${field}`
-              )
-            );
-          }
-
-          return r;
-        }
-
-        const relation = this.relations[groupKey];
-        if (relation === undefined) {
-          throw new Error(`존재하지 않는 relation 참조 ${groupKey}`);
-        }
-        const relSMD = SMDManager.get(relation.with);
-
-        if (
-          isOneToOneRelationProp(relation) ||
-          isBelongsToOneRelationProp(relation)
-        ) {
-          // -One Relation: JOIN 으로 처리
-          const relFields = fields.map((field) =>
-            field.split(".").slice(1).join(".")
-          );
-
-          // -One Relation에서 id 필드만 참조하는 경우 릴레이션 넘기지 않고 리턴
-          if (relFields.length === 1 && relFields[0] === "id") {
-            if (prefix === "") {
-              r.select = r.select.concat(`${this.table}.${groupKey}_id`);
-            } else {
-              r.select = r.select.concat(
-                `${prefix}.${groupKey}_id as ${prefix}__${groupKey}_id`
-              );
-            }
-            return r;
-          }
-
-          // innerOrOuter
-          const innerOrOuter = (() => {
-            if (isAlreadyOuterJoined) {
-              return "outer";
-            }
-
-            if (isOneToOneRelationProp(relation)) {
-              if (
-                relation.hasJoinColumn === true &&
-                (relation.nullable ?? false) === false
-              ) {
-                return "inner";
-              } else {
-                return "outer";
-              }
-            } else {
-              if (relation.nullable) {
-                return "outer";
-              } else {
-                return "inner";
-              }
-            }
-          })();
-          const relSubsetQuery = relSMD.resolveSubsetQuery(
-            `${prefix !== "" ? prefix + "." : ""}${groupKey}`,
-            relFields,
-            innerOrOuter === "outer"
-          );
-          r.select = r.select.concat(relSubsetQuery.select);
-          r.virtual = r.virtual.concat(relSubsetQuery.virtual);
-
-          const joinAs = prefix === "" ? groupKey : prefix + "__" + groupKey;
-          const fromTable = prefix === "" ? this.table : prefix;
-
-          let joinClause;
-          if (relation.customJoinClause) {
-            joinClause = {
-              custom: relation.customJoinClause,
-            };
-          } else {
-            let from, to;
-            if (isOneToOneRelationProp(relation)) {
-              if (relation.hasJoinColumn) {
-                from = `${fromTable}.${relation.name}_id`;
-                to = `${joinAs}.id`;
-              } else {
-                from = `${fromTable}.id`;
-                to = `${joinAs}.${inflection.underscore(
-                  this.names.fs.replace(/\-/g, "_")
-                )}_id`;
-              }
-            } else {
-              from = `${fromTable}.${relation.name}_id`;
-              to = `${joinAs}.id`;
-            }
-            joinClause = {
-              from,
-              to,
-            };
-          }
-
-          r.joins.push({
-            as: joinAs,
-            join: innerOrOuter,
-            table: relSMD.table,
-            ...joinClause,
-          });
-
-          // BelongsToOne 밑에 HasMany가 붙은 경우
-          if (relSubsetQuery.loaders.length > 0) {
-            const convertedLoaders = relSubsetQuery.loaders.map((loader) => {
-              const newAs = [groupKey, loader.as].join("__");
-              return {
-                as: newAs,
-                table: loader.table,
-                manyJoin: loader.manyJoin,
-                oneJoins: loader.oneJoins,
-                select: loader.select,
-              };
-            });
-
-            r.loaders = [...r.loaders, ...convertedLoaders];
-          }
-
-          r.joins = r.joins.concat(relSubsetQuery.joins);
-        } else if (
-          isHasManyRelationProp(relation) ||
-          isManyToManyRelationProp(relation)
-        ) {
-          // -Many Relation: Loader 로 처리
-          const relFields = fields.map((field) =>
-            field.split(".").slice(1).join(".")
-          );
-          const relSubsetQuery = relSMD.resolveSubsetQuery("", relFields);
-
-          let manyJoin: SubsetQuery["loaders"][number]["manyJoin"];
-          if (isHasManyRelationProp(relation)) {
-            manyJoin = {
-              fromTable: this.table,
-              fromCol: "id",
-              idField: prefix === "" ? `id` : `${prefix}__id`,
-              toTable: relSMD.table,
-              toCol: relation.joinColumn,
-            };
-          } else if (isManyToManyRelationProp(relation)) {
-            const [table1, table2] = relation.joinTable.split("__");
-
-            manyJoin = {
-              fromTable: this.table,
-              fromCol: "id",
-              idField: prefix === "" ? `id` : `${prefix}__id`,
-              through: {
-                table: relation.joinTable,
-                fromCol: `${inflection.singularize(table1)}_id`,
-                toCol: `${inflection.singularize(table2)}_id`,
-              },
-              toTable: relSMD.table,
-              toCol: "id",
-            };
-          } else {
-            throw new Error();
-          }
-
-          r.loaders.push({
-            as: groupKey,
-            table: relSMD.table,
-            manyJoin,
-            oneJoins: relSubsetQuery.joins,
-            select: relSubsetQuery.select,
-            loaders: relSubsetQuery.loaders,
-          });
-        }
-
-        return r;
-      },
-      {
-        select: [],
-        virtual: [],
-        joins: [],
-        loaders: [],
-      } as SubsetQuery
-    );
-    return result;
-  }
-
-  /*
-    FieldExpr[] 을 SMDPropNode[] 로 변환
-  */
-  fieldExprsToPropNodes(
-    fieldExprs: string[],
-    smd: SMD = this
-  ): EntityPropNode[] {
-    const groups = fieldExprs.reduce(
-      (result, fieldExpr) => {
-        let key, value, elseExpr;
-        if (fieldExpr.includes(".")) {
-          [key, ...elseExpr] = fieldExpr.split(".");
-          value = elseExpr.join(".");
-        } else {
-          key = "";
-          value = fieldExpr;
-        }
-        result[key] = (result[key] ?? []).concat(value);
-
-        return result;
-      },
-      {} as {
-        [k: string]: string[];
-      }
-    );
-
-    return Object.keys(groups)
-      .map((key) => {
-        const group = groups[key];
-
-        // 일반 prop 처리
-        if (key === "") {
-          return group.map((propName) => {
-            // uuid 개별 처리
-            if (propName === "uuid") {
-              return {
-                nodeType: "plain" as const,
-                prop: {
-                  type: "string",
-                  name: "uuid",
-                  length: 128,
-                } as StringProp,
-                children: [],
-              };
-            }
-
-            const prop = smd.propsDict[propName];
-            if (prop === undefined) {
-              throw new Error(`${this.id} -- 잘못된 FieldExpr ${propName}`);
-            }
-            return {
-              nodeType: "plain" as const,
-              prop,
-              children: [],
-            };
-          });
-        }
-
-        // relation prop 처리
-        const prop = smd.propsDict[key];
-        if (!isRelationProp(prop)) {
-          throw new Error(`잘못된 FieldExpr ${key}.${group[0]}`);
-        }
-        const relSMD = SMDManager.get(prop.with);
-
-        // relation -One 에 id 필드 하나인 경우
-        if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)) {
-          if (group.length == 1 && (group[0] === "id" || group[0] == "id?")) {
-            // id 하나만 있는지 체크해서, 하나만 있으면 상위 prop으로 id를 리턴
-            const idProp = relSMD.propsDict.id;
-            return {
-              nodeType: "plain" as const,
-              prop: {
-                ...idProp,
-                name: key + "_id",
-                nullable: prop.nullable,
-              },
-              children: [],
-            };
-          }
-        }
-
-        // -One 그외의 경우 object로 리턴
-        // -Many의 경우 array로 리턴
-        // Recursive 로 뎁스 처리
-        const children = this.fieldExprsToPropNodes(group, relSMD);
-        const nodeType =
-          isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)
-            ? ("object" as const)
-            : ("array" as const);
-
-        return {
-          prop,
-          children,
-          nodeType,
-        };
-      })
-      .flat();
-  }
-
-  getFieldExprs(
-    prefix = "",
-    maxDepth: number = 3,
-    froms: string[] = []
-  ): string[] {
-    return this.props
-      .map((prop) => {
-        const propName = [prefix, prop.name].filter((v) => v !== "").join(".");
-        if (propName === prefix) {
-          return null;
-        }
-        if (isRelationProp(prop)) {
-          if (maxDepth < 0) {
-            return null;
-          }
-          if (froms.includes(prop.with)) {
-            // 역방향 relation인 경우 제외
-            return null;
-          }
-          // 정방향 relation인 경우 recursive 콜
-          const relMd = SMDManager.get(prop.with);
-          return relMd.getFieldExprs(propName, maxDepth - 1, [
-            ...froms,
-            this.id,
-          ]);
-        }
-        return propName;
-      })
-      .flat()
-      .filter((f) => f !== null) as string[];
-  }
-
-  registerModulePaths() {
-    const basePath = `${this.names.fs}`;
-
-    // base-scheme
-    SMDManager.setModulePath(
-      `${this.id}BaseSchema`,
-      `${basePath}/${this.names.fs}.generated`
-    );
-
-    // subset
-    if (Object.keys(this.subsets).length > 0) {
-      SMDManager.setModulePath(
-        `${this.id}SubsetKey`,
-        `${basePath}/${this.names.fs}.generated`
-      );
-      SMDManager.setModulePath(
-        `${this.id}SubsetMapping`,
-        `${basePath}/${this.names.fs}.generated`
-      );
-      Object.keys(this.subsets).map((subsetKey) => {
-        SMDManager.setModulePath(
-          `${this.id}Subset${subsetKey.toUpperCase()}`,
-          `${basePath}/${this.names.fs}.generated`
-        );
-      });
-    }
-
-    // types
-    const typesModulePath = `${basePath}/${this.names.fs}.types`;
-    const typesFileDistPath = path.join(
-      Sonamu.apiRootPath,
-      `dist/application/${typesModulePath}.js`
-    );
-
-    if (fs.existsSync(typesFileDistPath)) {
-      const importPath = path.relative(__dirname, typesFileDistPath);
-      import(importPath).then((t) => {
-        this.types = Object.keys(t).reduce((result, key) => {
-          SMDManager.setModulePath(key, typesModulePath);
-          return {
-            ...result,
-            [key]: t[key],
-          };
-        }, {});
-      });
-    }
-
-    // enums
-    const enumsModulePath = `${basePath}/${this.names.fs}.enums`;
-    const enumsFileDistPath = path.join(
-      Sonamu.apiRootPath,
-      `/dist/application/${enumsModulePath}.js`
-    );
-    if (fs.existsSync(enumsFileDistPath)) {
-      const importPath = path.relative(__dirname, enumsFileDistPath);
-      import(importPath).then((t) => {
-        this.enums = Object.keys(t).reduce((result, key) => {
-          SMDManager.setModulePath(key, enumsModulePath);
-
-          // Enum Labels 별도 처리
-          if (key === inflection.underscore(this.id).toUpperCase()) {
-            this.enumLabels = t[key];
-          }
-          return {
-            ...result,
-            [key]: t[key],
-          };
-        }, {});
-      });
-    }
-  }
-
-  registerTableSpecs(): void {
-    const uniqueColumns = _.uniq(
-      this.indexes
-        .filter((idx) => idx.type === "unique")
-        .map((idx) => idx.columns)
-        .flat()
-    );
-
-    SMDManager.setTableSpec({
-      name: this.table,
-      uniqueColumns,
-    });
-  }
-}