sonamu 0.3.1 → 0.4.1

package/src/index.ts

@@ -2,9 +2,9 @@ export * from "./api/code-converters";
 export * from "./api/context";
 export * from "./api/decorators";
 export * from "./api/sonamu";
-export * from "./database/base-model";
 export * from "./database/db";
 export * from "./database/upsert-builder";
+export * from "./database/types";
 export * from "./exceptions/error-handler";
 export * from "./exceptions/so-exceptions";
 export * from "./entity/entity";

package/src/syncer/syncer.ts

@@ -75,6 +75,9 @@ import { Template__generated_http } from "../templates/generated_http.template";
 import { Sonamu } from "../api/sonamu";
 import { execSync } from "child_process";
 import { Template__generated_sso } from "../templates/generated_sso.template";
+import { Template__kysely_interface } from "../templates/kysely_types.template";
+import { DB } from "../database/db";
+import { setTimeout as setTimeoutPromises } from "timers/promises";
 
 type FileType = "model" | "types" | "functions" | "generated" | "entity";
 type GlobPattern = {
@@ -111,6 +114,7 @@ export class Syncer {
   }[] = [];
   types: { [typeName: string]: z.ZodObject<any> } = {};
   models: { [modelName: string]: unknown } = {};
+  isSyncing: boolean = false;
 
   get checksumsPath(): string {
     return path.join(Sonamu.apiRootPath, "/.so-checksum");
@@ -167,6 +171,23 @@ export class Syncer {
       return;
     }
 
+    const abc = new AbortController();
+    this.isSyncing = true;
+    const onSIGUSR2 = async () => {
+      if (this.isSyncing === false) {
+        process.exit(0);
+      }
+      console.log(chalk.magentaBright(`wait for syncing done....`));
+
+      // 싱크 완료 대기
+      try {
+        await setTimeoutPromises(20000, "waiting-sync", { signal: abc.signal });
+      } catch {}
+      console.log(chalk.magentaBright(`Syncing DONE!`));
+      process.exit(0);
+    };
+    process.on("SIGUSR2", onSIGUSR2);
+
     // 변경된 파일 찾기
     const diff = _.differenceWith(
       currentChecksums,
@@ -193,6 +214,18 @@ export class Syncer {
       console.log("// 액션: 스키마 생성");
       await this.actionGenerateSchemas();
 
+      if (
+        DB.baseConfig?.client === "kysely" &&
+        DB.baseConfig.types?.enabled !== false
+      ) {
+        console.log("// 액션: kysely 인터페이스 생성");
+        await this.generateTemplate(
+          "kysely_interface",
+          {},
+          { overwrite: true }
+        );
+      }
+
       // generated 싱크까지 동시에 처리 후 체크섬 갱신
       diffGroups["generated"] = _.uniq([
         ...(diffGroups["generated"] ?? []),
@@ -232,6 +265,11 @@ export class Syncer {
 
     // 저장
     await this.saveChecksums(currentChecksums);
+
+    // 싱크 종료
+    this.isSyncing = false;
+    abc.abort();
+    process.off("SIGUSR2", onSIGUSR2);
   }
 
   getEntityIdFromPath(filePaths: string[]): string[] {
@@ -275,23 +313,12 @@ export class Syncer {
   }
 
   async actionGenerateHttps(entityIds: string[]): Promise<string[]> {
-    return (
-      await Promise.all(
-        entityIds.map(async (entityId) =>
-          this.generateTemplate(
-            "generated_http",
-            {
-              entityId,
-            },
-            {
-              overwrite: true,
-            }
-          )
-        )
-      )
-    )
-      .flat()
-      .flat();
+    const [res] = await this.generateTemplate(
+      "generated_http",
+      { entityId: entityIds[0] },
+      { overwrite: true }
+    );
+    return res;
   }
 
   async copyFileWithReplaceCoreToShared(fromPath: string, toPath: string) {
@@ -661,12 +688,23 @@ export class Syncer {
       console.debug({ name, type, paramDec });
     }
 
-    return {
+    const result: ApiParam = {
       name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,
       type,
       optional: paramDec.optional === true,
       defaultDef: paramDec?.defaultDef,
     };
+
+    // 구조분해할당의 경우 타입이름 사용
+    if (
+      ts.isObjectBindingPattern(name) &&
+      ts.isTypeReferenceNode(paramDec.type) &&
+      ts.isIdentifier(paramDec.type.typeName)
+    ) {
+      result.name = inflection.camelize(paramDec.type.typeName.text, true);
+    }
+
+    return result;
   };
 
   printNode(
@@ -787,6 +825,8 @@ export class Syncer {
       return new Template__view_enums_dropdown();
     } else if (key === "view_enums_buttonset") {
       return new Template__view_enums_buttonset();
+    } else if (key === "kysely_interface") {
+      return new Template__kysely_interface();
     } else {
       throw new BadRequestException(`잘못된 템플릿 키 ${key}`);
     }
@@ -1340,15 +1380,17 @@ export class Syncer {
     // reload entities
     await EntityManager.reload();
 
-    // generate schemas
-    await this.actionGenerateSchemas();
-
-    // generate types
-    if (form.parentId === undefined) {
-      await this.generateTemplate("init_types", {
-        entityId: form.entityId,
-      });
-    }
+    // generate schemas, types
+    await Promise.all([
+      this.actionGenerateSchemas(),
+      ...(form.entityId === undefined
+        ? [
+            this.generateTemplate("init_types", {
+              entityId: form.entityId,
+            }),
+          ]
+        : []),
+    ]);
   }
 
   async delEntity(entityId: string): Promise<{ delPaths: string[] }> {

package/src/templates/generated_http.template.ts

@@ -112,6 +112,20 @@ export class Template__generated_http extends Template {
       return zodType._def.items.map((item: any) =>
         this.zodTypeToReqDefault(item, name)
       );
+    } else if (zodType instanceof z.ZodDate) {
+      return "2000-01-01";
+    } else if (zodType instanceof z.ZodLiteral) {
+      return zodType.value;
+    } else if (zodType instanceof z.ZodEffects) {
+      return this.zodTypeToReqDefault(zodType._def.schema, name);
+    } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {
+      const key = this.zodTypeToReqDefault(zodType._def.keyType, name) as any;
+      const value = this.zodTypeToReqDefault(zodType._def.valueType, name);
+      return { [key]: value };
+    } else if (zodType instanceof z.ZodSet) {
+      return [this.zodTypeToReqDefault(zodType._def.valueType, name)];
+    } else if (zodType instanceof z.ZodIntersection) {
+      return this.zodTypeToReqDefault(zodType._def.right, name);
     } else {
       // console.log(zodType);
       return `unknown-${zodType._type}`;

package/src/templates/kysely_types.template.ts

@@ -0,0 +1,205 @@
+import {
+  EntityProp,
+  isBelongsToOneRelationProp,
+  isBigIntegerProp,
+  isBooleanProp,
+  isDateProp,
+  isDateTimeProp,
+  isDecimalProp,
+  isDoubleProp,
+  isEnumProp,
+  isFloatProp,
+  isIntegerProp,
+  isJsonProp,
+  isRelationProp,
+  isStringProp,
+  isTextProp,
+  isTimeProp,
+  isTimestampProp,
+  isUuidProp,
+  isVirtualProp,
+} from "../types/types";
+import { EntityManager } from "../entity/entity-manager";
+import { Template } from "./base-template";
+import { SourceCode } from "./generated.template";
+import _ from "lodash";
+import { nonNullable } from "../utils/utils";
+import { Sonamu } from "../api";
+import { Entity } from "../entity/entity";
+import inflection from "inflection";
+import { DB } from "../database/db";
+import { KyselyBaseConfig } from "../database/types";
+
+export class Template__kysely_interface extends Template {
+  constructor() {
+    super("kysely_interface");
+  }
+
+  getTargetAndPath() {
+    const { dir } = Sonamu.config.api;
+    const { types } = DB.baseConfig as KyselyBaseConfig;
+    const outDir = types?.outDir ?? "src/typings";
+    const fileName = types?.fileName ?? "database.types.ts";
+
+    return {
+      target: `${dir}/${outDir}`,
+      path: fileName,
+    };
+  }
+
+  render() {
+    const entityIds = EntityManager.getAllIds();
+    const entities = entityIds.map((id) => EntityManager.get(id));
+    const enums = _.merge({}, ...entities.map((e) => e.enums));
+
+    const manyToManyTables = _.uniq(
+      entities.flatMap((e) =>
+        e.props
+          .map((p) => {
+            if (isRelationProp(p) && p.relationType === "ManyToMany") {
+              return p.joinTable;
+            }
+            return null;
+          })
+          .filter(nonNullable)
+      )
+    ).map((table) => {
+      const [fromTable, toTable] = table.split("__");
+      return {
+        table,
+        fromTable,
+        toTable,
+        interfaceName: `${inflection.classify(fromTable)}${inflection.classify(toTable)}Table`,
+      };
+    });
+
+    const sourceCodes: Omit<SourceCode, "label">[] = entities.map((entity) => {
+      const columns = entity.props.map((prop) =>
+        this.resolveColumn(prop, enums)
+      );
+
+      return {
+        lines: [
+          `interface ${entity.id}Table {
+              ${columns.join("\n")}
+            }`,
+          "",
+        ],
+        importKeys: [],
+      };
+    });
+
+    sourceCodes.push(
+      ...manyToManyTables.map(({ fromTable, toTable, interfaceName }) => {
+        return {
+          lines: [
+            `interface ${interfaceName} {
+            id: number;
+            ${inflection.singularize(fromTable)}_id: number;
+            ${inflection.singularize(toTable)}_id: number;
+          }`,
+            "",
+          ],
+          importKeys: [],
+        };
+      })
+    );
+
+    const sourceCode = sourceCodes.reduce(
+      (result, ts) => {
+        if (ts === null) {
+          return result;
+        }
+        return {
+          lines: [...result!.lines, ...ts.lines, ""],
+          importKeys: _.uniq([...result!.importKeys, ...ts.importKeys]),
+        };
+      },
+      {
+        lines: [],
+        importKeys: [],
+      } as Omit<SourceCode, "label">
+    );
+
+    return {
+      ...this.getTargetAndPath(),
+      body: sourceCode.lines.join("\n"),
+      importKeys: sourceCode.importKeys,
+      customHeaders: [
+        `import { Generated, ColumnType } from "kysely";`,
+        "",
+        `export interface KyselyDatabase {
+          ${entities.map((entity) => `${entity.table}: ${entity.id}Table`).join(",\n")}
+          ${manyToManyTables.map(({ table, interfaceName }) => `${table}: ${interfaceName}`).join(",\n")}
+        }`,
+        "",
+        `declare module "sonamu" {
+          export interface DatabaseExtend extends KyselyDatabase {}
+        }`,
+      ],
+    };
+  }
+
+  private resolveColumn(prop: EntityProp, enums: Entity["enums"]) {
+    if (isVirtualProp(prop)) {
+      return null;
+    }
+
+    if (prop.name === "id") {
+      return "id: Generated<number>";
+    }
+
+    if (isRelationProp(prop)) {
+      if (isBelongsToOneRelationProp(prop)) {
+        return `${prop.name}_id: ${prop.nullable ? "number | null" : "number"}`;
+      }
+      return null;
+    }
+
+    let type: string;
+
+    if (isIntegerProp(prop)) {
+      type = "number";
+    } else if (isBigIntegerProp(prop)) {
+      type = "string";
+    } else if (isStringProp(prop) || isTextProp(prop)) {
+      type = "string";
+    } else if (isEnumProp(prop)) {
+      const enumValues = enums[prop.id];
+      if (!enumValues) {
+        console.warn(`Enum values not found for ${prop.id}`);
+        return null;
+      }
+      type = Object.keys(enumValues.Values)
+        .map((e) => `"${e}"`)
+        .join(" | ");
+    } else if (isFloatProp(prop) || isDoubleProp(prop) || isDecimalProp(prop)) {
+      type = "number";
+    } else if (isBooleanProp(prop)) {
+      type = "boolean";
+    } else if (
+      isDateProp(prop) ||
+      isDateTimeProp(prop) ||
+      isTimeProp(prop) ||
+      isTimestampProp(prop)
+    ) {
+      type = "string";
+    } else if (isJsonProp(prop)) {
+      type = "string";
+    } else if (isUuidProp(prop)) {
+      type = "string";
+    } else {
+      console.warn(`Unknown prop type: ${(prop as any).type}`);
+      type = "unknown";
+    }
+
+    if (prop.nullable) {
+      type = `${type} | null`;
+    }
+    if (prop.dbDefault) {
+      type = `ColumnType<${type}, ${type} | undefined, ${type}>`;
+    }
+
+    return `${prop.name}: ${type};`;
+  }
+}

package/src/templates/model.template.ts

@@ -3,6 +3,7 @@ import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 import { Template__view_list } from "./view_list.template";
 import { Sonamu } from "../api";
+import { DB } from "../database/db";
 
 export class Template__model extends Template {
   constructor() {
@@ -24,7 +25,6 @@ export class Template__model extends Template {
     listParamsNode: RenderingNode
   ) {
     const names = EntityManager.getNamesFromId(entityId);
-    const entity = EntityManager.get(entityId);
 
     const vlTpl = new Template__view_list();
     if (listParamsNode?.children === undefined) {
@@ -34,144 +34,7 @@ export class Template__model extends Template {
 
     return {
       ...this.getTargetAndPath(names),
-      body: `
-import { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';
-import {
-  ${entityId}SubsetKey,
-  ${entityId}SubsetMapping,
-} from "../sonamu.generated";
-import {
-  ${names.camel}SubsetQueries,
-} from "../sonamu.generated.sso";
-import { ${entityId}ListParams, ${entityId}SaveParams } from "./${names.fs}.types";
-
-/*
-  ${entityId} Model
-*/
-class ${entityId}ModelClass extends BaseModelClass {
-  modelName = "${entityId}";
-
-  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${entityId}" })
-  async findById<T extends ${entityId}SubsetKey>(
-    subset: T,
-    id: number
-  ): Promise<${entityId}SubsetMapping[T]> {
-    const { rows } = await this.findMany(subset, {
-      id,
-      num: 1,
-      page: 1,
-    });
-    if (rows.length == 0) {
-      throw new NotFoundException(\`존재하지 않는 ${names.capital} ID \${id}\`);
-    }
-
-    return rows[0];
-  }
-
-  async findOne<T extends ${entityId}SubsetKey>(
-    subset: T,
-    listParams: ${entityId}ListParams
-  ): Promise<${entityId}SubsetMapping[T] | null> {
-    const { rows } = await this.findMany(subset, {
-      ...listParams,
-      num: 1,
-      page: 1,
-    });
-
-    return rows[0] ?? null;
-  }
-
-  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${names.capitalPlural}" })
-  async findMany<T extends ${entityId}SubsetKey>(
-    subset: T,
-    params: ${entityId}ListParams = {}
-  ): Promise<ListResult<${entityId}SubsetMapping[T]>> {
-    // params with defaults
-    params = {
-      num: 24,
-      page: 1,
-      search: "${def.search}",
-      orderBy: "${def.orderBy}",
-      ...params,
-    };
-
-    // build queries
-    let { rows, total } = await this.runSubsetQuery({
-      subset,
-      params,
-      subsetQuery: ${names.camel}SubsetQueries[subset],
-      build: ({ qb }) => {
-        // id
-        if (params.id) {
-          qb.whereIn("${entity.table}.id", asArray(params.id));
-        }
-
-        // search-keyword
-        if (params.search && params.keyword && params.keyword.length > 0) {
-          if (params.search === "id") {
-            qb.where("${entity.table}.id", params.keyword);
-          // } else if (params.search === "field") {
-          //   qb.where("${entity.table}.field", "like", \`%\${params.keyword}%\`);
-          } else {
-            throw new BadRequestException(
-              \`구현되지 않은 검색 필드 \${params.search}\`
-            );
-          }
-        }
-
-        // orderBy
-        if (params.orderBy) {
-          // default orderBy
-          const [orderByField, orderByDirec] = params.orderBy.split("-");
-          qb.orderBy("${entity.table}." + orderByField, orderByDirec);
-        }
-
-        return qb;
-      },
-      debug: false,
-    });
-
-    return {
-      rows,
-      total,
-    };
-  }
-
-  @api({ httpMethod: "POST" })
-  async save(
-    spa: ${entityId}SaveParams[]
-  ): Promise<number[]> {
-    const wdb = this.getDB("w");
-    const ub = this.getUpsertBuilder();
-
-    // register
-    spa.map((sp) => {
-      ub.register("${entity.table}", sp);
-    });
-
-    // transaction
-    return wdb.transaction(async (trx) => {
-      const ids = await ub.upsert(trx, "${entity.table}");
-
-      return ids;
-    });
-  }
-
-  @api({ httpMethod: "POST", guards: [ "admin" ] })
-  async del(ids: number[]): Promise<number> {
-    const wdb = this.getDB("w");
-
-    // transaction
-    await wdb.transaction(async (trx) => {
-      return trx("${entity.table}").whereIn("${entity.table}.id", ids).delete();
-    });
-
-    return ids.length;
-  }
-}
-
-export const ${entityId}Model = new ${entityId}ModelClass();
-      `.trim(),
+      body: DB.generator.generateModelTemplate(entityId, def),
       importKeys: [],
     };
   }

package/src/templates/service.template.ts

@@ -72,7 +72,9 @@ export class Template__service extends Template {
             const paramsWithoutContext = api.parameters.filter(
               (param) =>
                 !ApiParamType.isContext(param.type) &&
-                !ApiParamType.isRefKnex(param.type)
+                !ApiParamType.isRefKnex(param.type) &&
+                !ApiParamType.isRefKysely(param.type) &&
+                !(param.optional === true && param.name.startsWith("_")) // _로 시작하는 파라미터는 제외
             );
 
             // 파라미터 타입 정의

package/src/testing/_relation-graph.ts

@@ -0,0 +1,111 @@
+import { RelationNode, EntityProp, FixtureRecord } from "../types/types";
+import { EntityManager } from "../entity/entity-manager";
+import {
+  isRelationProp,
+  isBelongsToOneRelationProp,
+  isOneToOneRelationProp,
+  isManyToManyRelationProp,
+} from "../types/types";
+
+// 관계 그래프 처리를 별도 클래스로 분리
+export class RelationGraph {
+  private graph: Map<string, RelationNode> = new Map();
+
+  buildGraph(fixtures: FixtureRecord[]): void {
+    this.graph.clear();
+
+    // 1. 노드 추가
+    for (const fixture of fixtures) {
+      this.graph.set(fixture.fixtureId, {
+        fixtureId: fixture.fixtureId,
+        entityId: fixture.entityId,
+        related: new Set(),
+      });
+    }
+
+    // 2. 의존성 추가
+    for (const fixture of fixtures) {
+      const node = this.graph.get(fixture.fixtureId)!;
+
+      for (const [, column] of Object.entries(fixture.columns)) {
+        const prop = column.prop as EntityProp;
+
+        if (isRelationProp(prop)) {
+          if (
+            isBelongsToOneRelationProp(prop) ||
+            (isOneToOneRelationProp(prop) && prop.hasJoinColumn)
+          ) {
+            const relatedFixtureId = `${prop.with}#${column.value}`;
+            if (this.graph.has(relatedFixtureId)) {
+              node.related.add(relatedFixtureId);
+            }
+          } else if (isManyToManyRelationProp(prop)) {
+            // ManyToMany 관계의 경우 양방향 의존성 추가
+            const relatedIds = column.value as number[];
+            for (const relatedId of relatedIds) {
+              const relatedFixtureId = `${prop.with}#${relatedId}`;
+              if (this.graph.has(relatedFixtureId)) {
+                node.related.add(relatedFixtureId);
+                this.graph
+                  .get(relatedFixtureId)!
+                  .related.add(fixture.fixtureId);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  getInsertionOrder(): string[] {
+    const visited = new Set<string>();
+    const order: string[] = [];
+    const tempVisited = new Set<string>();
+
+    const visit = (fixtureId: string) => {
+      if (visited.has(fixtureId)) return;
+      if (tempVisited.has(fixtureId)) {
+        console.warn(`Circular dependency detected involving: ${fixtureId}`);
+        return;
+      }
+
+      tempVisited.add(fixtureId);
+
+      const node = this.graph.get(fixtureId)!;
+      const entity = EntityManager.get(node.entityId);
+
+      for (const depId of node.related) {
+        const depNode = this.graph.get(depId)!;
+
+        // BelongsToOne 관계이면서 nullable이 아닌 경우 먼저 방문
+        const relationProp = entity.props.find(
+          (prop) =>
+            isRelationProp(prop) &&
+            (isBelongsToOneRelationProp(prop) ||
+              (isOneToOneRelationProp(prop) && prop.hasJoinColumn)) &&
+            prop.with === depNode.entityId
+        );
+        if (relationProp && !relationProp.nullable) {
+          visit(depId);
+        }
+      }
+
+      tempVisited.delete(fixtureId);
+      visited.add(fixtureId);
+      order.push(fixtureId);
+    };
+
+    for (const fixtureId of this.graph.keys()) {
+      visit(fixtureId);
+    }
+
+    // circular dependency로 인해 방문되지 않은 fixtureId 추가
+    for (const fixtureId of this.graph.keys()) {
+      if (!visited.has(fixtureId)) {
+        order.push(fixtureId);
+      }
+    }
+
+    return order;
+  }
+}