sonamu 0.0.1

package/src/smd/smd-manager.ts

@@ -0,0 +1,141 @@
+import chalk from "chalk";
+import { glob } from "glob";
+import { dasherize, underscore, pluralize, camelize } from "inflection";
+import _ from "lodash";
+import path from "path";
+import { SMD } from "./smd";
+import { SMDInput } from "../types/types";
+import { Syncer } from "../syncer/syncer";
+
+export type SMDNamesRecord = Record<
+  | "fs"
+  | "fsPlural"
+  | "camel"
+  | "camelPlural"
+  | "capital"
+  | "capitalPlural"
+  | "upper"
+  | "constant",
+  string
+>;
+type TableSpec = {
+  name: string;
+  uniqueColumns: string[];
+};
+class SMDManagerClass {
+  private SMDs: Map<string, SMD> = new Map();
+  private 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(
+      Syncer.getInstance().config.appRootPath,
+      "/api/dist/application/**/*.smd.js"
+    );
+    !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
+
+    return new Promise((resolve) => {
+      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): SMDNamesRecord {
+    return {
+      fs: dasherize(underscore(smdId)).toLowerCase(),
+      fsPlural: dasherize(underscore(pluralize(smdId))).toLowerCase(),
+      camel: camelize(smdId, true),
+      camelPlural: pluralize(camelize(smdId, true)),
+      capital: smdId,
+      capitalPlural: pluralize(smdId),
+      upper: smdId.toUpperCase(),
+      constant: underscore(smdId).toUpperCase(),
+    };
+  }
+}
+
+export const SMDManager = new SMDManagerClass();

package/src/smd/smd-utils.ts

@@ -0,0 +1,266 @@
+import { camelize } from "inflection";
+import {
+  BelongsToOneRelationProp,
+  BigIntegerProp,
+  BooleanProp,
+  DateProp,
+  DateTimeProp,
+  DecimalProp,
+  DistributiveOmit,
+  DoubleProp,
+  EnumProp,
+  FloatProp,
+  HasManyRelationProp,
+  IntegerProp,
+  JsonProp,
+  ManyToManyRelationProp,
+  OneToOneRelationProp,
+  StringProp,
+  TextProp,
+  TimeProp,
+  TimestampProp,
+  UuidProp,
+  VirtualProp,
+} from "../types/types";
+
+export const p = {
+  integer,
+  bigInteger,
+  text,
+  string,
+  float,
+  double,
+  decimal,
+  boolean,
+  date,
+  dateTime,
+  time,
+  timestamp,
+  json,
+  uuid,
+  enums,
+  virtual,
+  relationOneToOne,
+  relationBelongsToOne,
+  relationHasMany,
+  relationManyToMany,
+};
+
+function integer(
+  name: string,
+  option?: Omit<IntegerProp, "name" | "type">
+): IntegerProp {
+  return {
+    name,
+    type: "integer",
+    ...option,
+  };
+}
+function bigInteger(
+  name: string,
+  option?: Omit<BigIntegerProp, "name" | "type">
+): BigIntegerProp {
+  return {
+    name,
+    type: "bigInteger",
+    ...option,
+  };
+}
+function text(name: string, option: Omit<TextProp, "name" | "type">): TextProp {
+  return {
+    name,
+    type: "text",
+    ...option,
+  };
+}
+function string(
+  name: string,
+  option: Omit<StringProp, "name" | "type">
+): StringProp {
+  return {
+    name,
+    type: "string",
+    ...option,
+  };
+}
+function float(
+  name: string,
+  option?: Omit<FloatProp, "name" | "type">
+): FloatProp {
+  return {
+    name,
+    type: "float",
+    ...option,
+  };
+}
+function double(
+  name: string,
+  option?: Omit<DoubleProp, "name" | "type">
+): DoubleProp {
+  return {
+    name,
+    type: "double",
+    ...option,
+  };
+}
+function decimal(
+  name: string,
+  option?: Omit<DecimalProp, "name" | "type">
+): DecimalProp {
+  return {
+    name,
+    type: "decimal",
+    ...option,
+  };
+}
+function boolean(
+  name: string,
+  option?: Omit<BooleanProp, "name" | "type">
+): BooleanProp {
+  return {
+    name,
+    type: "boolean",
+    ...option,
+  };
+}
+function date(
+  name: string,
+  option?: Omit<DateProp, "name" | "type"> & { now?: true }
+): DateProp {
+  if (option?.now === true) {
+    delete option.now;
+    option.dbDefault = "CURRENT_TIMESTAMP";
+  }
+  return {
+    name,
+    type: "date",
+    ...option,
+  };
+}
+function dateTime(
+  name: string,
+  option?: Omit<DateTimeProp, "name" | "type"> & { now?: true }
+): DateTimeProp {
+  if (option?.now === true) {
+    delete option.now;
+    option.dbDefault = "CURRENT_TIMESTAMP";
+  }
+  return {
+    name,
+    type: "dateTime",
+    ...option,
+  };
+}
+function time(
+  name: string,
+  option?: Omit<TimeProp, "name" | "type"> & { now?: true }
+): TimeProp {
+  if (option?.now === true) {
+    delete option.now;
+    option.dbDefault = "CURRENT_TIMESTAMP";
+  }
+  return {
+    name,
+    type: "time",
+    ...option,
+  };
+}
+function timestamp(
+  name: string,
+  option?: Omit<TimestampProp, "name" | "type"> & { now?: true }
+): TimestampProp {
+  if (option?.now === true) {
+    delete option.now;
+    option.dbDefault = "CURRENT_TIMESTAMP";
+  }
+  return {
+    name,
+    type: "timestamp",
+    ...option,
+  };
+}
+function json(name: string, option: Omit<JsonProp, "name" | "type">): JsonProp {
+  return {
+    name,
+    type: "json",
+    ...option,
+  };
+}
+function uuid(name: string, option: Omit<UuidProp, "name" | "type">): UuidProp {
+  return {
+    name,
+    type: "uuid",
+    ...option,
+  };
+}
+function enums(
+  name: string,
+  option: Omit<EnumProp, "name" | "type" | "id"> & { id?: string }
+): EnumProp {
+  return {
+    name,
+    type: "enum",
+    id: option.id ?? `$Model${camelize(name)}`,
+    ...option,
+  };
+}
+function virtual(
+  name: string,
+  option: Omit<
+    VirtualProp,
+    "name" | "type" | "index" | "unique" | "dbDefault" | "toFilter"
+  >
+): VirtualProp {
+  return {
+    name,
+    type: "virtual",
+    ...option,
+  };
+}
+function relationOneToOne(
+  name: string,
+  option: DistributiveOmit<
+    OneToOneRelationProp,
+    "name" | "type" | "relationType"
+  >
+): OneToOneRelationProp {
+  return {
+    name,
+    type: "relation",
+    relationType: "OneToOne",
+    ...option,
+  };
+}
+function relationBelongsToOne(
+  name: string,
+  option: Omit<BelongsToOneRelationProp, "name" | "type" | "relationType">
+): BelongsToOneRelationProp {
+  return {
+    name,
+    type: "relation",
+    relationType: "BelongsToOne",
+    ...option,
+  };
+}
+function relationHasMany(
+  name: string,
+  option: Omit<HasManyRelationProp, "name" | "type" | "relationType">
+): HasManyRelationProp {
+  return {
+    name,
+    type: "relation",
+    relationType: "HasMany",
+    ...option,
+  };
+}
+function relationManyToMany(
+  name: string,
+  option: Omit<ManyToManyRelationProp, "name" | "type" | "relationType">
+): ManyToManyRelationProp {
+  return {
+    name,
+    type: "relation",
+    relationType: "ManyToMany",
+    ...option,
+  };
+}