sonamu 0.0.39 → 0.0.41

package/src/api/decorators.ts

@@ -20,6 +20,7 @@ export type ApiDecoratorOptions = {
   path?: string;
   resourceName?: string;
   guards?: string[];
+  description?: string;
 };
 export const registeredApis: {
   modelName: string;

package/src/index.ts

@@ -9,6 +9,7 @@ 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 "./syncer/syncer";
 export * from "./testing/fixture-manager";
 export * from "./types/types";

package/src/smd/migrator.ts

@@ -48,6 +48,7 @@ import {
   isEnumProp,
   isIntegerProp,
   isKnexError,
+  RelationOn,
 } from "../types/types";
 import { propIf } from "../utils/lodash-able";
 import { SMDManager } from "./smd-manager";
@@ -477,20 +478,22 @@ export class Migrator {
                 );
               }
             } else {
-              const smdForeigns = sortBy(smdSet.foreigns, (a) =>
-                [a.to, ...a.columns].join("-")
-              ).map((smdForeign) => {
+              const replaceNoActionOnMySQL = (f: MigrationForeign) => {
                 // MySQL에서 RESTRICT와 NO ACTION은 동일함
-                const { onDelete, onUpdate } = smdForeign;
+                const { onDelete, onUpdate } = f;
                 return {
-                  ...smdForeign,
+                  ...f,
                   onUpdate: onUpdate === "RESTRICT" ? "NO ACTION" : onUpdate,
                   onDelete: onDelete === "RESTRICT" ? "NO ACTION" : onDelete,
                 };
-              });
+              };
+
+              const smdForeigns = sortBy(smdSet.foreigns, (a) =>
+                [a.to, ...a.columns].join("-")
+              ).map((f) => replaceNoActionOnMySQL(f));
               const dbForeigns = sortBy(dbSet.foreigns, (a) =>
                 [a.to, ...a.columns].join("-")
-              );
+              ).map((f) => replaceNoActionOnMySQL(f));
 
               if (equal(smdForeigns, dbForeigns) === false) {
                 console.dir({ smdForeigns, dbForeigns }, { depth: null });
@@ -534,7 +537,7 @@ export class Migrator {
     기존 테이블 정보 읽어서 MigrationSet 형식으로 리턴
   */
   async getMigrationSetFromDB(table: string): Promise<MigrationSet | null> {
-    let dbColumns: any[], dbIndexes: any[], dbForeigns: any[];
+    let dbColumns: DBColumn[], dbIndexes: DBIndex[], dbForeigns: DBForeign[];
     try {
       [dbColumns, dbIndexes, dbForeigns] = await this.readTable(table);
     } catch (e: unknown) {
@@ -554,7 +557,7 @@ export class Migrator {
         ...propIf(dbColumn.Default !== null, {
           defaultTo:
             dbColType.type === "float"
-              ? parseFloat(dbColumn.Default).toString()
+              ? parseFloat(dbColumn.Default ?? "0").toString()
               : dbColumn.Default,
         }),
       };
@@ -592,8 +595,8 @@ export class Migrator {
       return {
         columns: [dbForeign.from],
         to: `${dbForeign.referencesTable}.${dbForeign.referencesField}`,
-        onUpdate: dbForeign.onUpdate,
-        onDelete: dbForeign.onDelete,
+        onUpdate: dbForeign.onUpdate as RelationOn,
+        onDelete: dbForeign.onDelete as RelationOn,
       };
     });
 
@@ -691,7 +694,9 @@ export class Migrator {
   /*
     기존 테이블 읽어서 cols, indexes 반환
   */
-  async readTable(tableName: string): Promise<[any, any, any]> {
+  async readTable(
+    tableName: string
+  ): Promise<[DBColumn[], DBIndex[], DBForeign[]]> {
     // 테이블 정보
     try {
       const [cols] = await this.targets.compare!.raw(
@@ -1563,3 +1568,37 @@ export class Migrator {
     );
   }
 }
+
+type DBColumn = {
+  Field: string;
+  Type: string;
+  Null: string;
+  Key: string;
+  Default: string | null;
+  Extra: string;
+};
+type DBIndex = {
+  Table: string;
+  Non_unique: number;
+  Key_name: string;
+  Seq_in_index: number;
+  Column_name: string;
+  Collation: string | null;
+  Cardinality: number | null;
+  Sub_part: number | null;
+  Packed: string | null;
+  Null: string;
+  Index_type: string;
+  Comment: string;
+  Index_comment: string;
+  Visible: string;
+  Expression: string | null;
+};
+type DBForeign = {
+  keyName: string;
+  from: string;
+  referencesTable: string;
+  referencesField: string;
+  onDelete: string;
+  onUpdate: string;
+};

package/src/smd/smd-manager.ts

@@ -24,7 +24,7 @@ type TableSpec = {
 };
 class SMDManagerClass {
   private SMDs: Map<string, SMD> = new Map();
-  private modulePaths: Map<string, string> = new Map();
+  public modulePaths: Map<string, string> = new Map();
   private tableSpecs: Map<string, TableSpec> = new Map();
   public isAutoloaded: boolean = false;
 

package/src/smd/smd.ts

@@ -132,7 +132,11 @@ export class SMD {
 
   /*
    */
-  resolveSubsetQuery(prefix: string, fields: string[]): SubsetQuery {
+  resolveSubsetQuery(
+    prefix: string,
+    fields: string[],
+    isAlreadyOuterJoined: boolean = false
+  ): SubsetQuery {
     // prefix 치환 (prefix는 ToOneRelation이 복수로 붙은 경우 모두 __로 변경됨)
     prefix = prefix.replace(/\./g, "__");
 
@@ -203,9 +207,33 @@ export class SMD {
             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
+            relFields,
+            innerOrOuter === "outer"
           );
           r.select = r.select.concat(relSubsetQuery.select);
           r.virtual = r.virtual.concat(relSubsetQuery.virtual);
@@ -240,32 +268,9 @@ export class SMD {
             };
           }
 
-          const outerOrInner = (() => {
-            // 대상 컬럼이 nullable인 경우 outer, 아닌 경우 inner
-            // OneToOneRelation의 경우 joinColumn이 없는 경우 해당 relation을 찾아가 확인해야 함 (customJoin의 경우 고려하지 않음)
-            if (
-              isOneToOneRelationProp(relation) &&
-              relation.hasJoinColumn === false
-            ) {
-              const oppositeRelationProp = relSMD.props.find(
-                (prop) =>
-                  isOneToOneRelationProp(prop) &&
-                  prop.with === this.id &&
-                  prop.hasJoinColumn === true
-              );
-              if (oppositeRelationProp?.nullable === true) {
-                return "outer";
-              } else {
-                return "inner";
-              }
-            }
-
-            return relation.nullable === true ? "outer" : "inner";
-          })();
-
           r.joins.push({
             as: joinAs,
-            join: outerOrInner,
+            join: innerOrOuter,
             table: relSMD.table,
             ...joinClause,
           });

package/src/syncer/syncer.ts

@@ -801,7 +801,7 @@ export class Syncer {
     }
 
     const rendered = template.render(options, ...extra);
-    const resolved = this.resolveRenderedTemplate(key, rendered);
+    const resolved = await this.resolveRenderedTemplate(key, rendered);
 
     let preTemplateResolved: PathAndCode[] = [];
     if (rendered.preTemplates) {
@@ -817,10 +817,10 @@ export class Syncer {
     return [resolved, ...preTemplateResolved];
   }
 
-  resolveRenderedTemplate(
+  async resolveRenderedTemplate(
     key: TemplateKey,
     result: RenderedTemplate
-  ): PathAndCode {
+  ): Promise<PathAndCode> {
     const { target, path: filePath, body, importKeys, customHeaders } = result;
 
     // import 할 대상의 대상 path 추출
@@ -873,7 +873,7 @@ export class Syncer {
     const formatted =
       key === "generated_http"
         ? [header, body].join("\n\n")
-        : prettier.format([header, body].join("\n\n"), {
+        : await prettier.format([header, body].join("\n\n"), {
             parser: "typescript",
           });
 

package/src/types/types.ts

@@ -127,6 +127,7 @@ type _RelationProp = {
   with: string;
   nullable?: boolean;
   toFilter?: true;
+  desc?: string;
 };
 export type OneToOneRelationProp = _RelationProp & {
   relationType: "OneToOne";