sonamu 0.3.1 → 0.4.1

package/src/database/drivers/kysely/base-model.ts

@@ -0,0 +1,89 @@
+import { Kysely, SelectQueryBuilder } from "kysely";
+import { SubsetQuery, isCustomJoinClause } from "../../../types/types";
+import { BaseModelClassAbstract } from "../../base-model";
+import { DB } from "../../db";
+import { DBPreset, Database } from "../../types";
+import { KyselyClient } from "./client";
+import { UpsertBuilder } from "../../upsert-builder";
+import { UndirectedOrderByExpression } from "kysely/dist/cjs/parser/order-by-parser";
+import { EntityManager } from "../../../entity/entity-manager";
+import inflection from "inflection";
+
+type TB = keyof Database;
+
+export class BaseModelClass extends BaseModelClassAbstract<"kysely"> {
+  getDB(which: DBPreset): Kysely<Database> {
+    return DB.getDB(which) as Kysely<Database>;
+  }
+
+  async destroy(): Promise<void> {
+    return DB.destroy();
+  }
+
+  getUpsertBuilder() {
+    return new UpsertBuilder<"kysely">();
+  }
+
+  protected applyJoins(
+    clonedQb: KyselyClient,
+    joins: SubsetQuery["joins"]
+  ): KyselyClient {
+    for (const join of joins) {
+      if (isCustomJoinClause(join)) {
+        throw new Error("Custom join clause is not supported in Kysely");
+      }
+
+      if (join.join === "inner") {
+        clonedQb.innerJoin(`${join.table} as ${join.as}`, join.from, join.to);
+      } else if (join.join === "outer") {
+        clonedQb.leftJoin(`${join.table} as ${join.as}`, join.from, join.to);
+      }
+    }
+
+    return clonedQb;
+  }
+
+  protected async executeCountQuery(
+    qb: SelectQueryBuilder<Database, TB, any>
+  ): Promise<number> {
+    const result = await qb
+      .clearSelect()
+      .select((eb) => eb.fn.count("id" as any).as("total"))
+      .executeTakeFirstOrThrow();
+    return Number(result.total);
+  }
+
+  parseOrderBy(
+    orderBy: string
+  ): [
+    UndirectedOrderByExpression<Database, keyof Database, {}>,
+    "asc" | "desc",
+  ] {
+    const [_column, order] = orderBy.split("-");
+    // FIXME: 조인 2개 이상일 때 처리
+    const [table, column] = _column.includes(".")
+      ? _column.split(".")
+      : [inflection.tableize(this.modelName), _column];
+
+    if (order !== "asc" && order !== "desc") {
+      throw new Error("parseOrderBy: Invalid order");
+    }
+    if (!column) {
+      throw new Error("parseOrderBy: Invalid column");
+    }
+
+    const entity = EntityManager.get(inflection.classify(table));
+    if (!entity.props.find((p) => p.name === column)) {
+      throw new Error("parseOrderBy: 현재 엔티티에 존재하지 않는 컬럼입니다: ");
+    }
+
+    return [
+      `${table}.${column}` as unknown as UndirectedOrderByExpression<
+        Database,
+        keyof Database,
+        {}
+      >,
+      order as "asc" | "desc",
+    ];
+  }
+}

package/src/database/drivers/kysely/client.ts

@@ -0,0 +1,309 @@
+import {
+  ComparisonOperatorExpression,
+  FileMigrationProvider,
+  Kysely,
+  Migrator,
+  MysqlDialect,
+  Transaction,
+  sql,
+} from "kysely";
+import {
+  Database,
+  DatabaseClient,
+  DriverSpec,
+  KyselyConfig,
+  WhereClause,
+} from "../../types";
+import _ from "lodash";
+import { asArray } from "../../../utils/model";
+import { createPool } from "mysql2";
+
+type TB = keyof Database;
+type TE = TB & string;
+
+// 확장된 Transaction 타입 정의
+export type ExtendedKyselyTrx = Transaction<Database> &
+  DatabaseClient<"kysely">;
+
+export class KyselyClient implements DatabaseClient<"kysely"> {
+  private kysely: Kysely<Database>;
+
+  get connectionInfo() {
+    return {
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.user,
+      password: this.config.password,
+    };
+  }
+
+  private _qb?: DriverSpec["kysely"]["queryBuilder"];
+  set qb(qb: DriverSpec["kysely"]["queryBuilder"]) {
+    this._qb = qb;
+  }
+  get qb() {
+    if (!this._qb) {
+      throw new Error("QueryBuilder is not initialized");
+    }
+    return this._qb;
+  }
+
+  private _migrator?: Migrator;
+  set migrator(migrator: Migrator) {
+    this._migrator = migrator;
+  }
+  get migrator() {
+    if (!this._migrator) {
+      throw new Error("Migrator is not initialized");
+    }
+    return this._migrator;
+  }
+
+  get sql() {
+    const bindings = this.qb.compile().parameters.map((p) => JSON.stringify(p));
+    return this.qb.compile().sql.replace(/\?/g, () => bindings.shift()!);
+  }
+
+  constructor(
+    private config: KyselyConfig,
+    kysely?: Kysely<Database>
+  ) {
+    const { onCreateConnection, migration, ...rest } = this.config;
+
+    this.kysely =
+      kysely ??
+      new Kysely({
+        dialect: new MysqlDialect({
+          onCreateConnection,
+          pool: createPool(rest),
+        }),
+      });
+
+    this.migrator = new Migrator({
+      db: this.kysely,
+      provider: new FileMigrationProvider(migration as any),
+    });
+  }
+
+  from(table: string) {
+    this.qb = this.kysely.selectFrom(table as TB);
+    return this;
+  }
+
+  innerJoin(table: string, k1: string, k2: string) {
+    this.qb = this.qb.innerJoin(table as TB, k1 as TB, k2 as TB);
+    return this;
+  }
+
+  leftJoin(table: string, k1: string, k2: string) {
+    this.qb = this.qb.leftJoin(table as TB, k1 as TB, k2 as TB);
+    return this;
+  }
+
+  clearSelect() {
+    this.qb = this.qb.clearSelect();
+    return this;
+  }
+
+  select(columns: string | string[]) {
+    this.qb = this.qb.select(asArray(columns) as TE[]);
+    return this;
+  }
+
+  selectAll() {
+    this.qb = this.qb.selectAll();
+    return this;
+  }
+
+  where(ops: WhereClause | WhereClause[]) {
+    if (typeof ops[0] === "string") {
+      ops = [ops as WhereClause];
+    }
+    for (const [lhs, op, rhs] of asArray(ops)) {
+      this.qb = this.qb.where(
+        lhs as any,
+        op as ComparisonOperatorExpression,
+        rhs
+      );
+    }
+    return this;
+  }
+
+  orWhere(ops: WhereClause | WhereClause[]) {
+    this.qb = this.qb.where((eb) =>
+      eb.or(
+        ops.map(([lhs, op, rhs]) =>
+          eb(lhs as any, op as ComparisonOperatorExpression, rhs)
+        )
+      )
+    );
+    return this;
+  }
+
+  async insert(table: string, data: any[]) {
+    await this.kysely
+      .insertInto(table as TB)
+      .values(data)
+      .execute();
+  }
+
+  async upsert(table: string, data: any[]) {
+    const q = this.kysely
+      .insertInto(table as TB)
+      .values(data)
+      .onDuplicateKeyUpdate(() => {
+        const updates: Record<string, any> = {};
+        // 첫 번째 레코드의 키들을 기준으로 업데이트 설정
+        Object.keys(data[0]).forEach((key) => {
+          updates[key] = sql`VALUES(${sql.raw(key)})`; // VALUES 구문 사용
+        });
+        return updates;
+      });
+    await q.execute();
+  }
+
+  limit(limit: number) {
+    this.qb = this.qb.limit(limit);
+    return this;
+  }
+
+  offset(offset: number) {
+    this.qb = this.qb.offset(offset);
+    return this;
+  }
+
+  count(column: string, alias?: string) {
+    this.qb = this.qb.select((eb) =>
+      eb.fn.count(column as any).as(alias ?? column)
+    );
+    return this;
+  }
+
+  distinct(column: string) {
+    this.qb = this.qb.distinctOn(column as any);
+    return this;
+  }
+
+  first() {
+    this.qb = this.qb.limit(1);
+    return this;
+  }
+
+  async execute(trx?: ExtendedKyselyTrx): Promise<any[]> {
+    if (trx) {
+      const { rows } = await trx.executeQuery(this.qb.compile());
+      return rows as any[];
+    }
+    return this.qb.execute();
+  }
+
+  async pluck(column: string): Promise<any[]> {
+    const result = await this.execute();
+    return result.map((row) => row[column]);
+  }
+
+  createRawQuery(query: string, bindings?: any[]) {
+    if (bindings?.length) {
+      query = query.replace(
+        /\?/g,
+        () => sql.lit(bindings.shift()).compile(this.kysely).sql
+      );
+    }
+    return sql.raw(query).compile(this.kysely).sql;
+  }
+
+  async raw<R>(query: string, bindings?: any[]): Promise<R[]> {
+    if (bindings?.length) {
+      query = query.replace(
+        /\?/g,
+        () => sql.lit(bindings.shift()).compile(this.kysely).sql
+      );
+    }
+    const { rows } = await sql.raw(query).execute(this.kysely);
+    return rows as R[];
+  }
+
+  async truncate(table: string) {
+    await sql`truncate table ${sql.table(table)}`.execute(this.kysely);
+  }
+
+  trx<T>(callback: (trx: KyselyClient) => Promise<T>) {
+    return this.kysely
+      .transaction()
+      .execute(async (trx) => callback(new KyselyClient(this.config, trx)));
+  }
+
+  destroy() {
+    return this.kysely.destroy();
+  }
+
+  clearQueryParts(parts: ("order" | "offset" | "limit")[]) {
+    for (const part of parts) {
+      switch (part) {
+        case "order":
+          this.qb = this.qb.clearOrderBy();
+          break;
+        case "offset":
+          this.qb = this.qb.clearOffset();
+          break;
+        case "limit":
+          this.qb = this.qb.clearLimit();
+          break;
+      }
+    }
+    return this;
+  }
+
+  clone() {
+    const client = new KyselyClient(this.config);
+    client.qb = this.qb;
+    return client;
+  }
+
+  // Migrator
+
+  async getMigrations() {
+    const result = await this.migrator.getMigrations();
+    return result.filter((r) => !r.executedAt).map((r) => r.name);
+  }
+
+  async status() {
+    const pendings = await this.getMigrations();
+    return 0 - pendings.length;
+  }
+
+  async migrate() {
+    const { results, error } = await this.migrator.migrateToLatest();
+    if (error) {
+      throw error;
+    }
+
+    return [0, results?.map((r) => r.migrationName)];
+  }
+
+  async rollback() {
+    const { results, error } = await this.migrator.migrateDown();
+    if (error) {
+      throw error;
+    }
+
+    return [0, results?.map((r) => r.migrationName)];
+  }
+
+  async rollbackAll() {
+    while (true) {
+      const { error, results } = await this.migrator.migrateDown();
+
+      if (error) {
+        console.error("Error while rollbackAll:", error);
+        throw error;
+      }
+
+      if (!results || results.length === 0) {
+        console.log("RollbackAll completed");
+        break;
+      }
+    }
+  }
+}

package/src/database/drivers/kysely/db.ts

@@ -0,0 +1,238 @@
+import _ from "lodash";
+import { promises } from "fs";
+import path from "path";
+import { createPool } from "mysql2";
+import {
+  DBPreset,
+  Database,
+  KyselyBaseConfig,
+  KyselyConfig,
+  SonamuKyselyDBConfig,
+} from "../../types";
+import { FileMigrationProviderProps, Kysely, MysqlDialect, sql } from "kysely";
+import { KyselyClient } from "./client";
+import { DBClass } from "../../db.abstract";
+import { Sonamu } from "../../../api";
+import { KyselyGenerator } from "./generator";
+
+export class DBKyselyClass extends DBClass {
+  public migrationTable = "kysely_migration";
+  public generator: KyselyGenerator = new KyselyGenerator();
+  public baseConfig?: KyselyBaseConfig;
+
+  public declare _fullConfig?: SonamuKyselyDBConfig;
+  set fullConfig(config: SonamuKyselyDBConfig) {
+    this._fullConfig = config;
+  }
+  get fullConfig() {
+    if (!this._fullConfig) {
+      throw new Error("DB Config has not been initialized");
+    }
+    return this._fullConfig;
+  }
+
+  private wdb?: Kysely<Database>;
+  private rdb?: Kysely<Database>;
+
+  private _tdb: KyselyClient | null = null;
+  set tdb(tdb: KyselyClient) {
+    this._tdb = tdb;
+  }
+  get tdb(): KyselyClient {
+    if (this._tdb === null) {
+      throw new Error("tdb has not been initialized");
+    }
+    return this._tdb;
+  }
+
+  private _fdb: KyselyClient | null = null;
+  set fdb(fdb: KyselyClient) {
+    this._fdb = fdb;
+  }
+  get fdb(): KyselyClient {
+    if (this._fdb === null) {
+      throw new Error("fdb has not been initialized");
+    }
+    return this._fdb;
+  }
+
+  get connectionInfo() {
+    return _.mapValues(this.fullConfig, (config) => ({
+      host: config.host ?? "localhost",
+      port: config.port ?? 3306,
+      database: config.database,
+      user: config.user,
+      password: config.password,
+    }));
+  }
+
+  constructor() {
+    super();
+  }
+
+  init(config: KyselyBaseConfig) {
+    this.baseConfig = config;
+    this.fullConfig = this.generateDBConfig(config);
+  }
+
+  async testInit() {
+    if (this._tdb !== null) {
+      return;
+    }
+
+    if (this.fullConfig.test && this.fullConfig.production_master) {
+      const tConnInfo = this.fullConfig.test;
+      const pConnInfo = this.fullConfig.production_master;
+
+      if (
+        `${tConnInfo.host ?? "localhost"}:${tConnInfo.port ?? 3306}/${
+          tConnInfo.database
+        }` ===
+        `${pConnInfo.host ?? "localhost"}:${pConnInfo.port ?? 3306}/${pConnInfo.database}`
+      ) {
+        throw new Error(
+          `테스트DB와 프로덕션DB에 동일한 데이터베이스가 사용되었습니다.`
+        );
+      }
+    }
+
+    this.tdb = new KyselyClient(this.fullConfig.test);
+    this.fdb = new KyselyClient(this.fullConfig.fixture_local);
+  }
+
+  get config(): SonamuKyselyDBConfig {
+    return this.fullConfig;
+  }
+
+  getDB(which: DBPreset) {
+    const instanceName = which === "w" ? "wdb" : "rdb";
+
+    if (!this[instanceName]) {
+      const _config: KyselyConfig = this.getCurrentConfig(which);
+      const { onCreateConnection, migration, ...config } = _config;
+
+      this[instanceName] = new Kysely<Database>({
+        dialect: new MysqlDialect({
+          onCreateConnection,
+          pool: createPool(config),
+        }),
+      });
+    }
+
+    return this[instanceName]!;
+  }
+
+  getClient(mode: keyof SonamuKyselyDBConfig) {
+    return new KyselyClient(this.fullConfig[mode]);
+  }
+
+  async destroy(): Promise<void> {
+    if (this.wdb !== undefined) {
+      await this.wdb.destroy();
+      this.wdb = undefined;
+    }
+    if (this.rdb !== undefined) {
+      await this.rdb.destroy();
+      this.rdb = undefined;
+    }
+  }
+
+  async testDestroy() {
+    if (this._tdb) {
+      await this._tdb.destroy();
+      this._tdb = null;
+    }
+    if (this._fdb) {
+      await this._fdb.destroy();
+      this._fdb = null;
+    }
+  }
+
+  raw(db: Kysely<Database>, query: string) {
+    return sql`${query}`.execute(db);
+  }
+
+  private generateDBConfig(config: KyselyBaseConfig): SonamuKyselyDBConfig {
+    const defaultKyselyConfig = _.merge(
+      {
+        migration: {
+          fs: promises,
+          path,
+          migrationFolder: path.join(Sonamu.apiRootPath, "/dist/migrations"),
+        } as FileMigrationProviderProps,
+        port: 3306,
+        host: "localhost",
+        database: config.database,
+      },
+      config.defaultOptions
+    );
+
+    // 로컬 환경 설정
+    const test = _.merge({}, defaultKyselyConfig, {
+      database: `${config.database}_test`,
+    });
+
+    const fixture_local = _.merge({}, defaultKyselyConfig, {
+      database: `${config.database}_fixture`,
+    });
+
+    // 개발 환경 설정
+    const devMasterOptions = config.environments?.development;
+    const devSlaveOptions = config.environments?.development_slave;
+    const development_master = _.merge(
+      {},
+      defaultKyselyConfig,
+      devMasterOptions
+    );
+    const development_slave = _.merge(
+      {},
+      defaultKyselyConfig,
+      devMasterOptions,
+      devSlaveOptions
+    );
+    const fixture_remote = _.merge({}, defaultKyselyConfig, devMasterOptions, {
+      database: `${config.database}_fixture`,
+    });
+
+    // 프로덕션 환경 설정
+    const prodMasterOptions = config.environments?.production ?? {};
+    const prodSlaveOptions = config.environments?.production_slave ?? {};
+    const production_master = _.merge(
+      {},
+      defaultKyselyConfig,
+      prodMasterOptions
+    );
+    const production_slave = _.merge(
+      {},
+      defaultKyselyConfig,
+      prodMasterOptions,
+      prodSlaveOptions
+    );
+
+    return {
+      test,
+      fixture_local,
+      fixture_remote,
+      development_master,
+      development_slave,
+      production_master,
+      production_slave,
+    };
+  }
+
+  /**
+   * keys에 해당하는 설정들을 중복없이 가져옵니다. (host/port/database가 같은 설정은 중복으로 처리합니다.)
+   */
+  getUniqueConfigs(keys: (keyof SonamuKyselyDBConfig)[]) {
+    const targets = keys.map((key) => ({
+      connKey: key,
+      options: this.fullConfig[key as keyof SonamuKyselyDBConfig],
+    }));
+
+    return _.uniqBy(
+      targets,
+      ({ options }) =>
+        `${options.host ?? "localhost"}:${options.port ?? 3306}/${options.database}`
+    );
+  }
+}