sonamu 0.3.1 → 0.4.1

package/src/database/drivers/knex/generator.ts

@@ -0,0 +1,659 @@
+import _ from "lodash";
+import prettier from "prettier";
+import inflection from "inflection";
+import equal from "fast-deep-equal";
+import {
+  GenMigrationCode,
+  MigrationColumn,
+  MigrationForeign,
+  MigrationIndex,
+} from "../../../types/types";
+import { CodeGenerator } from "../../code-generator";
+import { EntityManager } from "../../../entity/entity-manager";
+
+export class KnexGenerator extends CodeGenerator {
+  async generateCreateCode_ColumnAndIndexes(
+    table: string,
+    columns: MigrationColumn[],
+    indexes: MigrationIndex[]
+  ): Promise<GenMigrationCode> {
+    // 컬럼, 인덱스 처리
+    const lines: string[] = [
+      'import { Knex } from "knex";',
+      "",
+      "export async function up(knex: Knex): Promise<void> {",
+      `return knex.schema.createTable("${table}", (table) => {`,
+      "// columns",
+      ...this.genColumnDefinitions(columns),
+      "",
+      "// indexes",
+      ...this.genIndexDefinitions(indexes),
+      "});",
+      "}",
+      "",
+      "export async function down(knex: Knex): Promise<void> {",
+      ` return knex.schema.dropTable("${table}");`,
+      "}",
+    ];
+    return {
+      table,
+      type: "normal",
+      title: `create__${table}`,
+      formatted: await prettier.format(lines.join("\n"), {
+        parser: "typescript",
+      }),
+    };
+  }
+
+  /*
+  테이블 생성하는 케이스 - FK 생성
+*/
+  async generateCreateCode_Foreign(
+    table: string,
+    foreigns: MigrationForeign[]
+  ): Promise<GenMigrationCode[]> {
+    if (foreigns.length === 0) {
+      return [];
+    }
+
+    const { up, down } = this.genForeignDefinitions(table, foreigns);
+    if (up.length === 0 && down.length === 0) {
+      console.log("fk 가 뭔가 다릅니다");
+      return [];
+    }
+
+    const lines: string[] = [
+      'import { Knex } from "knex";',
+      "",
+      "export async function up(knex: Knex): Promise<void> {",
+      `return knex.schema.alterTable("${table}", (table) => {`,
+      "// create fk",
+      ...up,
+      "});",
+      "}",
+      "",
+      "export async function down(knex: Knex): Promise<void> {",
+      `return knex.schema.alterTable("${table}", (table) => {`,
+      "// drop fk",
+      ...down,
+      "});",
+      "}",
+    ];
+
+    const foreignKeysString = foreigns
+      .map((foreign) => foreign.columns.join("_"))
+      .join("_");
+    return [
+      {
+        table,
+        type: "foreign",
+        title: `foreign__${table}__${foreignKeysString}`,
+        formatted: await prettier.format(lines.join("\n"), {
+          parser: "typescript",
+        }),
+      },
+    ];
+  }
+
+  async generateAlterCode_ColumnAndIndexes(
+    table: string,
+    entityColumns: MigrationColumn[],
+    entityIndexes: MigrationIndex[],
+    dbColumns: MigrationColumn[],
+    dbIndexes: MigrationIndex[]
+  ): Promise<GenMigrationCode[]> {
+    /*
+      세부 비교 후 다른점 찾아서 코드 생성
+
+      1. 컬럼갯수 다름: MD에 있으나, DB에 없다면 추가
+      2. 컬럼갯수 다름: MD에 없으나, DB에 있다면 삭제
+      3. 그외 컬럼(컬럼 갯수가 동일하거나, 다른 경우 동일한 컬럼끼리) => alter
+      4. 다른거 다 동일하고 index만 변경되는 경우
+
+      ** 컬럼명을 변경하는 경우는 따로 핸들링하지 않음
+      => drop/add 형태의 마이그레이션 코드가 생성되는데, 수동으로 rename 코드로 수정하여 처리
+    */
+
+    // 각 컬럼 이름 기준으로 add, drop, alter 여부 확인
+    const alterColumnsTo = this.getAlterColumnsTo(entityColumns, dbColumns);
+
+    // 추출된 컬럼들을 기준으로 각각 라인 생성
+    const alterColumnLinesTo = this.getAlterColumnLinesTo(
+      alterColumnsTo,
+      entityColumns
+    );
+
+    // 인덱스의 add, drop 여부 확인
+    const alterIndexesTo = this.getAlterIndexesTo(entityIndexes, dbIndexes);
+
+    // 추출된 인덱스들을 기준으로 각각 라인 생성
+    const alterIndexLinesTo = this.getAlterIndexLinesTo(
+      alterIndexesTo,
+      alterColumnsTo
+    );
+
+    const lines: string[] = [
+      'import { Knex } from "knex";',
+      "",
+      "export async function up(knex: Knex): Promise<void> {",
+      `return knex.schema.alterTable("${table}", (table) => {`,
+      ...(alterColumnsTo.add.length > 0 ? alterColumnLinesTo.add.up : []),
+      ...(alterColumnsTo.drop.length > 0 ? alterColumnLinesTo.drop.up : []),
+      ...(alterColumnsTo.alter.length > 0 ? alterColumnLinesTo.alter.up : []),
+      ...(alterIndexesTo.add.length > 0 ? alterIndexLinesTo.add.up : []),
+      ...(alterIndexesTo.drop.length > 0 ? alterIndexLinesTo.drop.up : []),
+      "})",
+      "}",
+      "",
+      "export async function down(knex: Knex): Promise<void> {",
+      `return knex.schema.alterTable("${table}", (table) => {`,
+      ...(alterColumnsTo.add.length > 0 ? alterColumnLinesTo.add.down : []),
+      ...(alterColumnsTo.drop.length > 0 ? alterColumnLinesTo.drop.down : []),
+      ...(alterColumnsTo.alter.length > 0 ? alterColumnLinesTo.alter.down : []),
+      ...(alterIndexLinesTo.add.down.length > 0
+        ? alterIndexLinesTo.add.down
+        : []),
+      ...(alterIndexLinesTo.drop.down.length > 0
+        ? alterIndexLinesTo.drop.down
+        : []),
+      "})",
+      "}",
+    ];
+
+    const formatted = await prettier.format(lines.join("\n"), {
+      parser: "typescript",
+    });
+
+    const title = [
+      "alter",
+      table,
+      ...(["add", "drop", "alter"] as const)
+        .map((action) => {
+          const len = alterColumnsTo[action].length;
+          if (len > 0) {
+            return action + len;
+          }
+          return null;
+        })
+        .filter((part) => part !== null),
+    ].join("_");
+
+    return [
+      {
+        table,
+        title,
+        formatted,
+        type: "normal",
+      },
+    ];
+  }
+
+  async generateAlterCode_Foreigns(
+    table: string,
+    entityForeigns: MigrationForeign[],
+    dbForeigns: MigrationForeign[]
+  ): Promise<GenMigrationCode[]> {
+    const getKey = (mf: MigrationForeign): string => {
+      return [mf.columns.join("-"), mf.to].join("///");
+    };
+    const fkTo = entityForeigns.reduce(
+      (result, entityF) => {
+        const matchingDbF = dbForeigns.find(
+          (dbF) => getKey(entityF) === getKey(dbF)
+        );
+        if (!matchingDbF) {
+          result.add.push(entityF);
+          return result;
+        }
+
+        if (equal(entityF, matchingDbF) === false) {
+          result.alterSrc.push(matchingDbF);
+          result.alterDst.push(entityF);
+          return result;
+        }
+        return result;
+      },
+      {
+        add: [] as MigrationForeign[],
+        alterSrc: [] as MigrationForeign[],
+        alterDst: [] as MigrationForeign[],
+      }
+    );
+
+    const linesTo = {
+      add: this.genForeignDefinitions(table, fkTo.add),
+      alterSrc: this.genForeignDefinitions(table, fkTo.alterSrc),
+      alterDst: this.genForeignDefinitions(table, fkTo.alterDst),
+    };
+
+    const lines: string[] = [
+      'import { Knex } from "knex";',
+      "",
+      "export async function up(knex: Knex): Promise<void> {",
+      `return knex.schema.alterTable("${table}", (table) => {`,
+      ...linesTo.add.up,
+      ...linesTo.alterSrc.down,
+      ...linesTo.alterDst.up,
+      "})",
+      "}",
+      "",
+      "export async function down(knex: Knex): Promise<void> {",
+      `return knex.schema.alterTable("${table}", (table) => {`,
+      ...linesTo.add.down,
+      ...linesTo.alterDst.down,
+      ...linesTo.alterSrc.up,
+      "})",
+      "}",
+    ];
+
+    const formatted = await prettier.format(lines.join("\n"), {
+      parser: "typescript",
+    });
+
+    const title = [
+      "alter",
+      table,
+      "foreigns",
+      // TODO 바뀌는 부분
+    ].join("_");
+
+    return [
+      {
+        table,
+        title,
+        formatted,
+        type: "normal",
+      },
+    ];
+  }
+
+  generateModelTemplate(
+    entityId: string,
+    def: { orderBy: string; search: string }
+  ) {
+    const names = EntityManager.getNamesFromId(entityId);
+    const entity = EntityManager.get(entityId);
+
+    return `
+import { ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';
+import { BaseModelClass } from 'sonamu/knex';
+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();
+  }
+
+  /*
+  MigrationColumn[] 읽어서 컬럼 정의하는 구문 생성
+*/
+  private genColumnDefinitions(columns: MigrationColumn[]): string[] {
+    return columns.map((column) => {
+      const chains: string[] = [];
+      if (column.name === "id") {
+        return `table.increments().primary();`;
+      }
+
+      // FIXME: float(M,D) deprecated -> decimal(M,D) 이용하도록 하고, float/double 처리 추가
+      if (column.type === "float" || column.type === "decimal") {
+        chains.push(
+          `${column.type}('${column.name}', ${column.precision}, ${column.scale})`
+        );
+      } else {
+        let columnType = column.type;
+        let extraType: string | undefined;
+        if (columnType.includes("text") && columnType !== "text") {
+          extraType = columnType;
+          columnType = "text";
+        }
+        chains.push(
+          `${column.type}('${column.name}'${
+            column.length ? `, ${column.length}` : ""
+          }${extraType ? `, '${extraType}'` : ""})`
+        );
+      }
+      if (column.unsigned) {
+        chains.push("unsigned()");
+      }
+
+      chains.push(column.nullable ? "nullable()" : "notNullable()");
+
+      if (column.defaultTo !== undefined) {
+        if (
+          typeof column.defaultTo === "string" &&
+          column.defaultTo.startsWith(`"`)
+        ) {
+          chains.push(`defaultTo(${column.defaultTo})`);
+        } else {
+          chains.push(`defaultTo(knex.raw('${column.defaultTo}'))`);
+        }
+      }
+
+      return `table.${chains.join(".")};`;
+    });
+  }
+
+  /*
+  MigrationIndex[] 읽어서 인덱스/유니크 정의하는 구문 생성
+*/
+  private genIndexDefinitions(indexes: MigrationIndex[]): string[] {
+    if (indexes.length === 0) {
+      return [];
+    }
+    const lines = _.uniq(
+      indexes.reduce((r, index) => {
+        r.push(
+          `table.${index.type}([${index.columns
+            .map((col) => `'${col}'`)
+            .join(",")}])`
+        );
+        return r;
+      }, [] as string[])
+    );
+    return lines;
+  }
+
+  private getAlterColumnLinesTo(
+    columnsTo: ReturnType<KnexGenerator["getAlterColumnsTo"]>,
+    entityColumns: MigrationColumn[]
+  ) {
+    let linesTo = {
+      add: {
+        up: [] as string[],
+        down: [] as string[],
+      },
+      drop: {
+        up: [] as string[],
+        down: [] as string[],
+      },
+      alter: {
+        up: [] as string[],
+        down: [] as string[],
+      },
+    };
+
+    linesTo.add = {
+      up: ["// add", ...this.genColumnDefinitions(columnsTo.add)],
+      down: [
+        "// rollback - add",
+        `table.dropColumns(${columnsTo.add
+          .map((col) => `'${col.name}'`)
+          .join(", ")})`,
+      ],
+    };
+    linesTo.drop = {
+      up: [
+        "// drop",
+        `table.dropColumns(${columnsTo.drop
+          .map((col) => `'${col.name}'`)
+          .join(", ")})`,
+      ],
+      down: [
+        "// rollback - drop",
+        ...this.genColumnDefinitions(columnsTo.drop),
+      ],
+    };
+    linesTo.alter = columnsTo.alter.reduce(
+      (r, dbColumn) => {
+        const entityColumn = entityColumns.find(
+          (col) => col.name == dbColumn.name
+        );
+        if (entityColumn === undefined) {
+          return r;
+        }
+
+        // 컬럼 변경사항
+        const columnDiffUp = _.difference(
+          this.genColumnDefinitions([entityColumn]),
+          this.genColumnDefinitions([dbColumn])
+        );
+        const columnDiffDown = _.difference(
+          this.genColumnDefinitions([dbColumn]),
+          this.genColumnDefinitions([entityColumn])
+        );
+        if (columnDiffUp.length > 0) {
+          r.up = [
+            ...r.up,
+            "// alter column",
+            ...columnDiffUp.map((l) => l.replace(";", "") + ".alter();"),
+          ];
+          r.down = [
+            ...r.down,
+            "// rollback - alter column",
+            ...columnDiffDown.map((l) => l.replace(";", "") + ".alter();"),
+          ];
+        }
+
+        return r;
+      },
+      {
+        up: [] as string[],
+        down: [] as string[],
+      }
+    );
+
+    return linesTo;
+  }
+
+  private getAlterIndexLinesTo(
+    indexesTo: ReturnType<KnexGenerator["getAlterIndexesTo"]>,
+    columnsTo: ReturnType<KnexGenerator["getAlterColumnsTo"]>
+  ) {
+    let linesTo = {
+      add: {
+        up: [] as string[],
+        down: [] as string[],
+      },
+      drop: {
+        up: [] as string[],
+        down: [] as string[],
+      },
+    };
+
+    // 인덱스가 추가되는 경우, 컬럼과 같이 추가된 케이스에는 drop에서 제외해야함!
+    linesTo.add = {
+      up: ["// add indexes", ...this.genIndexDefinitions(indexesTo.add)],
+      down: [
+        "// rollback - add indexes",
+        ...indexesTo.add
+          .filter(
+            (index) =>
+              index.columns.every((colName) =>
+                columnsTo.add.map((col) => col.name).includes(colName)
+              ) === false
+          )
+          .map(
+            (index) =>
+              `table.drop${inflection.capitalize(index.type)}([${index.columns
+                .map((columnName) => `'${columnName}'`)
+                .join(",")}])`
+          ),
+      ],
+    };
+    // 인덱스가 삭제되는 경우, 컬럼과 같이 삭제된 케이스에는 drop에서 제외해야함!
+    linesTo.drop = {
+      up: [
+        ...indexesTo.drop
+          .filter(
+            (index) =>
+              index.columns.every((colName) =>
+                columnsTo.drop.map((col) => col.name).includes(colName)
+              ) === false
+          )
+          .map(
+            (index) =>
+              `table.drop${inflection.capitalize(index.type)}([${index.columns
+                .map((columnName) => `'${columnName}'`)
+                .join(",")}])`
+          ),
+      ],
+      down: [
+        "// rollback - drop indexes",
+        ...this.genIndexDefinitions(indexesTo.drop),
+      ],
+    };
+
+    return linesTo;
+  }
+
+  /*
+    MigrationForeign[] 읽어서 외부키 constraint 정의하는 구문 생성
+  */
+  private genForeignDefinitions(
+    table: string,
+    foreigns: MigrationForeign[]
+  ): { up: string[]; down: string[] } {
+    return foreigns.reduce(
+      (r, foreign) => {
+        const columnsStringQuote = foreign.columns
+          .map((col) => `'${col.replace(`${table}.`, "")}'`)
+          .join(",");
+        r.up.push(
+          `table.foreign('${foreign.columns.join(",")}')
+            .references('${foreign.to}')
+            .onUpdate('${foreign.onUpdate}')
+            .onDelete('${foreign.onDelete}')`
+        );
+        r.down.push(`table.dropForeign([${columnsStringQuote}])`);
+        return r;
+      },
+      {
+        up: [] as string[],
+        down: [] as string[],
+      }
+    );
+  }
+}