sonamu 0.3.1 → 0.4.1

package/src/database/db.abstract.ts

@@ -0,0 +1,75 @@
+import { Knex } from "knex";
+import { Kysely } from "kysely";
+import path from "path";
+import { KnexClient } from "./drivers/knex/client";
+import { KyselyClient } from "./drivers/kysely/client";
+import {
+  SonamuDBConfig,
+  DBPreset,
+  Database,
+  SonamuDBBaseConfig,
+  KnexConfig,
+} from "./types";
+
+// db.ts에 포함시킬 경우 순환참조 발생
+
+export abstract class DBClass {
+  public _fullConfig?: SonamuDBConfig;
+  set fullConfig(config: SonamuDBConfig) {
+    this._fullConfig = config;
+  }
+  get fullConfig() {
+    if (!this._fullConfig) {
+      throw new Error("FixtureManager has not been initialized");
+    }
+    return this._fullConfig;
+  }
+
+  abstract tdb: KnexClient | KyselyClient;
+  abstract fdb: KnexClient | KyselyClient;
+
+  abstract testInit(): Promise<void>;
+  abstract getDB(which: DBPreset): Knex | Kysely<Database>;
+  abstract destroy(): Promise<void>;
+  abstract raw(db: Knex | Kysely<Database>, query: string): any;
+
+  async getBaseConfig(rootPath: string): Promise<SonamuDBBaseConfig> {
+    const baseConfigPath = path.join(rootPath, "/dist/configs/db.js");
+    const module = await import(baseConfigPath);
+    const config = module.default?.default ?? module.default ?? module;
+    return config;
+  }
+
+  getCurrentConfig(which?: DBPreset) {
+    switch (process.env.NODE_ENV ?? "development") {
+      case "development":
+      case "staging":
+        return which === "w"
+          ? this.fullConfig["development_master"]
+          : this.fullConfig["development_slave"] ??
+              this.fullConfig["development_master"];
+        break;
+      case "production":
+        return which === "w"
+          ? this.fullConfig["production_master"]
+          : this.fullConfig["production_slave"] ??
+              this.fullConfig["production_master"];
+        break;
+      case "test":
+        return this.fullConfig["test"];
+        break;
+      default:
+        throw new Error(
+          `현재 ENV ${process.env.NODE_ENV}에는 설정 가능한 DB설정이 없습니다.`
+        );
+    }
+  }
+
+  toClient(db: Knex | Kysely<Database>): KnexClient | KyselyClient {
+    if (db instanceof Kysely) {
+      return new KyselyClient(this.getCurrentConfig(), db);
+    } else {
+      return new KnexClient(this.getCurrentConfig() as KnexConfig, db);
+    }
+  }
+}

package/src/database/db.ts

@@ -1,84 +1,23 @@
-export type DBPreset = "w" | "r";
-import knex, { Knex } from "knex";
 import path from "path";
-import { Sonamu } from "../api";
-import { ServiceUnavailableException } from "../exceptions/so-exceptions";
-
-export type SonamuDBConfig = {
-  development_master: Knex.Config;
-  development_slave: Knex.Config;
-  test: Knex.Config;
-  fixture_local: Knex.Config;
-  fixture_remote: Knex.Config;
-  production_master: Knex.Config;
-  production_slave: Knex.Config;
-};
-
-class DBClass {
-  private wdb?: Knex;
-  private rdb?: Knex;
-
-  async readKnexfile(): Promise<SonamuDBConfig> {
-    const dbConfigPath: string = path.join(
-      Sonamu.apiRootPath,
-      "/dist/configs/db.js"
-    );
-    try {
-      const knexfileModule = await import(dbConfigPath);
-      return (knexfileModule.default?.default ??
-        knexfileModule.default ??
-        knexfileModule) as SonamuDBConfig;
-    } catch {}
-
-    throw new ServiceUnavailableException(
-      `DB설정 파일을 찾을 수 없습니다. ${dbConfigPath}`
-    );
-  }
-
-  getDB(which: DBPreset): Knex {
-    const dbConfig = Sonamu.dbConfig;
-
-    const instanceName = which === "w" ? "wdb" : "rdb";
-
-    if (!this[instanceName]) {
-      let config: Knex.Config;
-      switch (process.env.NODE_ENV ?? "development") {
-        case "development":
-        case "staging":
-          config =
-            which === "w"
-              ? dbConfig["development_master"]
-              : dbConfig["development_slave"] ?? dbConfig["development_master"];
-          break;
-        case "production":
-          config =
-            which === "w"
-              ? dbConfig["production_master"]
-              : dbConfig["production_slave"] ?? dbConfig["production_master"];
-          break;
-        case "test":
-          config = dbConfig["test"];
-          break;
-        default:
-          throw new Error(
-            `현재 ENV ${process.env.NODE_ENV}에는 설정 가능한 DB설정이 없습니다.`
-          );
-      }
-      this[instanceName] = knex(config);
-    }
-
-    return this[instanceName]!;
-  }
-
-  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;
-    }
+import { findApiRootPath } from "../utils/utils";
+import { DBKnexClass } from "./drivers/knex/db";
+import { DBKyselyClass } from "./drivers/kysely/db";
+import { SonamuDBBaseConfig } from "./types";
+
+const dbConfigPath: string = path.join(
+  findApiRootPath(),
+  "/dist/configs/db.js"
+);
+const knexfileModule = await import(dbConfigPath);
+
+export const DB = (() => {
+  const config = (knexfileModule.default?.default ??
+    knexfileModule.default ??
+    knexfileModule) as SonamuDBBaseConfig;
+  if (config.client === "knex") {
+    return new DBKnexClass();
+  } else if (config.client === "kysely") {
+    return new DBKyselyClass();
   }
-}
-export const DB = new DBClass();
+  throw new Error("지원하지 않는 DB 클라이언트입니다.");
+})();

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

@@ -0,0 +1,55 @@
+// base-model.knex.ts
+import { Knex } from "knex";
+import { SubsetQuery, isCustomJoinClause } from "../../../types/types";
+import { BaseModelClassAbstract } from "../../base-model";
+import { DB } from "../../db";
+import { KnexClient } from "./client";
+import { DBPreset } from "../../types";
+import { UpsertBuilder } from "../../upsert-builder";
+
+export class BaseModelClass extends BaseModelClassAbstract<"knex"> {
+  getDB(which: DBPreset): Knex {
+    return DB.getDB(which) as Knex;
+  }
+
+  async destroy(): Promise<void> {
+    return DB.destroy();
+  }
+
+  getUpsertBuilder() {
+    return new UpsertBuilder<"knex">();
+  }
+
+  protected applyJoins(
+    clonedQb: KnexClient,
+    joins: SubsetQuery["joins"]
+  ): KnexClient {
+    for (const join of joins) {
+      if (isCustomJoinClause(join)) {
+        if (join.join === "inner") {
+          clonedQb.qb = clonedQb.qb.innerJoin(
+            `${join.table} as ${join.as}`,
+            join.custom as any
+          );
+        } else {
+          clonedQb.qb = clonedQb.qb.leftJoin(
+            `${join.table} as ${join.as}`,
+            join.custom as any
+          );
+        }
+      } else {
+        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: Knex.QueryBuilder): Promise<number> {
+    const result = await qb.clear("select").count("* as total").first();
+    return Number(result?.total) ?? 0;
+  }
+}

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

@@ -0,0 +1,209 @@
+import knex, { Knex } from "knex";
+import { DatabaseClient, KnexConfig, WhereClause } from "../../types";
+import { asArray } from "../../../utils/model";
+import _ from "lodash";
+import { KnexGenerator } from "./generator";
+
+// 확장된 Transaction 타입 정의
+export type ExtendedKnexTrx = Knex.Transaction & DatabaseClient<"knex">;
+
+export class KnexClient implements DatabaseClient<"knex"> {
+  private knex: Knex;
+  generator: KnexGenerator = new KnexGenerator();
+
+  get connectionInfo() {
+    return {
+      host: this.knex.client.config.connection?.host ?? "localhost",
+      port: this.knex.client.config.connection?.port ?? 3306,
+      database: this.knex.client.config.connection?.database ?? "",
+      user: this.knex.client.config.connection?.user ?? "",
+      password: this.knex.client.config.connection?.password ?? "",
+    };
+  }
+
+  private _qb?: Knex.QueryBuilder;
+  set qb(qb: Knex.QueryBuilder) {
+    this._qb = qb;
+  }
+  get qb() {
+    if (!this._qb) {
+      throw new Error("QueryBuilder is not initialized");
+    }
+    return this._qb;
+  }
+
+  get sql() {
+    return this.qb.toQuery();
+  }
+
+  constructor(
+    private config: KnexConfig,
+    _knex?: Knex
+  ) {
+    this.knex = _knex ?? knex(this.config);
+  }
+
+  from(table: string): KnexClient {
+    this.qb = this.knex.from(table);
+    return this;
+  }
+
+  innerJoin(table: string, k1: string, k2: string) {
+    this.qb = this.qb.innerJoin(table, k1, k2);
+    return this;
+  }
+
+  leftJoin(table: string, k1: string, k2: string) {
+    this.qb = this.qb.leftJoin(table, k1, k2);
+    return this;
+  }
+
+  clearSelect() {
+    this.qb = this.qb.clearSelect();
+    return this;
+  }
+
+  select(columns: string | string[]) {
+    this.qb = this.qb.select(asArray(columns));
+    return this;
+  }
+
+  selectAll() {
+    this.qb = this.qb.select("*");
+    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, op, rhs);
+    }
+    return this;
+  }
+
+  orWhere(ops: WhereClause | WhereClause[]) {
+    this.qb = this.qb.orWhere((qb) => {
+      for (const [lhs, op, rhs] of asArray(ops)) {
+        qb.andWhere(lhs, op, rhs);
+      }
+    });
+    return this;
+  }
+
+  async insert(table: string, data: any[]) {
+    await this.knex(table).insert(data);
+  }
+
+  async upsert(table: string, data: any[]) {
+    const q = this.knex(table).insert(data);
+    const updateFields = Array.isArray(data) ? Object.keys(data[0]) : data;
+    await q.onDuplicateUpdate.apply(q, updateFields);
+  }
+
+  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.count(alias ? `${column} as ${alias}` : column);
+    return this;
+  }
+
+  distinct(column: string) {
+    this.qb = this.qb.distinct(column);
+    return this;
+  }
+
+  first() {
+    this.qb = this.qb.limit(1);
+    return this;
+  }
+
+  async execute(trx?: ExtendedKnexTrx): Promise<any[]> {
+    if (trx) {
+      return this.qb.transacting(trx);
+    }
+    return this.qb;
+  }
+
+  async pluck(column: string): Promise<any[]> {
+    return this.qb.pluck(column);
+  }
+
+  createRawQuery(query: string, bindings?: any[]) {
+    if (bindings?.length) {
+      return this.knex.raw(query, bindings).toQuery();
+    }
+    return this.knex.raw(query).toQuery();
+  }
+
+  async raw<R>(query: string, bindings?: any[]): Promise<R[]> {
+    if (bindings?.length) {
+      return (await this.knex.raw(query, bindings))[0];
+    }
+    return (await this.knex.raw(query))[0];
+  }
+
+  async truncate(table: string) {
+    await this.knex(table).truncate();
+  }
+
+  trx(callback: (trx: KnexClient) => Promise<any>) {
+    return this.knex.transaction((trx) =>
+      callback(new KnexClient(this.config, trx))
+    );
+  }
+
+  destroy() {
+    return this.knex.destroy();
+  }
+
+  clearQueryParts(parts: ("order" | "offset" | "limit")[]) {
+    this.qb = parts.reduce((acc, part) => acc.clear(part), this.qb.clone());
+    return this;
+  }
+
+  clone() {
+    const client = new KnexClient(this.config);
+    client.qb = this.qb.clone();
+    return client;
+  }
+
+  // Migrator
+
+  async getMigrations() {
+    const [, result] = (await this.knex.migrate.list()) as [
+      unknown,
+      {
+        file: string;
+        directory: string;
+      }[],
+    ];
+
+    return result.map((r) => r.file.replace(".js", ""));
+  }
+
+  async status() {
+    return this.knex.migrate.status();
+  }
+
+  async migrate() {
+    return this.knex.migrate.latest();
+  }
+
+  async rollback() {
+    return this.knex.migrate.rollback();
+  }
+
+  async rollbackAll() {
+    return this.knex.migrate.rollback(undefined, true);
+  }
+}

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

@@ -0,0 +1,227 @@
+import _ from "lodash";
+import { DBPreset, KnexBaseConfig, SonamuKnexDBConfig } from "../../types";
+import knex, { Knex } from "knex";
+import { KnexClient } from "./client";
+import { DBClass } from "../../db.abstract";
+import { attachOnDuplicateUpdate } from "./plugins/knex-on-duplicate-update";
+import { KnexGenerator } from "./generator";
+
+export class DBKnexClass extends DBClass {
+  public migrationTable = "knex_migrations";
+  public generator: KnexGenerator = new KnexGenerator();
+  public baseConfig?: KnexBaseConfig;
+
+  public declare _fullConfig?: SonamuKnexDBConfig;
+  set fullConfig(config: SonamuKnexDBConfig) {
+    this._fullConfig = config;
+  }
+  get fullConfig() {
+    if (!this._fullConfig) {
+      throw new Error("DB Config has not been initialized");
+    }
+    return this._fullConfig;
+  }
+
+  private wdb?: Knex;
+  private rdb?: Knex;
+
+  private _tdb: KnexClient | null = null;
+  set tdb(tdb: KnexClient) {
+    this._tdb = tdb;
+  }
+  get tdb(): KnexClient {
+    if (this._tdb === null) {
+      throw new Error("tdb has not been initialized");
+    }
+    return this._tdb;
+  }
+
+  private _fdb: KnexClient | null = null;
+  set fdb(fdb: KnexClient) {
+    this._fdb = fdb;
+  }
+  get fdb(): KnexClient {
+    if (this._fdb === null) {
+      throw new Error("fdb has not been initialized");
+    }
+    return this._fdb;
+  }
+
+  get connectionInfo() {
+    return _.mapValues(this.fullConfig, ({ connection }) => ({
+      host: connection.host ?? "localhost",
+      port: connection.port ?? 3306,
+      database: connection.database,
+      user: connection.user,
+      password: connection.password,
+    }));
+  }
+
+  constructor() {
+    super();
+    attachOnDuplicateUpdate();
+  }
+
+  init(config: KnexBaseConfig) {
+    this.baseConfig = config;
+    this.fullConfig = this.generateDBConfig(config);
+  }
+
+  async testInit() {
+    if (this._tdb !== null) {
+      return;
+    }
+
+    if (this.fullConfig.test && this.fullConfig.production_master) {
+      const tConn = this.connectionInfo.test;
+      const pConn = this.connectionInfo.production_master;
+
+      if (
+        `${tConn.host ?? "localhost"}:${tConn.port ?? 3306}/${
+          tConn.database
+        }` ===
+        `${pConn.host ?? "localhost"}:${pConn.port ?? 3306}/${pConn.database}`
+      ) {
+        throw new Error(
+          `테스트DB와 프로덕션DB에 동일한 데이터베이스가 사용되었습니다.`
+        );
+      }
+    }
+
+    this.tdb = new KnexClient(this.fullConfig.test);
+    this.fdb = new KnexClient(this.fullConfig.fixture_local);
+  }
+
+  getDB(which: DBPreset) {
+    const instanceName = which === "w" ? "wdb" : "rdb";
+
+    if (!this[instanceName]) {
+      const config = this.getCurrentConfig(which);
+      this[instanceName] = knex(config);
+    }
+
+    return this[instanceName]!;
+  }
+
+  getClient(mode: keyof SonamuKnexDBConfig) {
+    return new KnexClient(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: Knex, query: string) {
+    return db.raw(query);
+  }
+
+  private generateDBConfig(config: KnexBaseConfig): SonamuKnexDBConfig {
+    const defaultKnexConfig = _.merge(
+      {
+        client: "mysql2",
+        pool: {
+          min: 1,
+          max: 5,
+        },
+        migrations: {
+          extension: "js",
+          directory: "./dist/migrations",
+        },
+        connection: {
+          host: "localhost",
+          port: 3306,
+          database: config.database,
+        },
+      },
+      config.defaultOptions
+    );
+
+    // 로컬 환경 설정
+    const test = _.merge({}, defaultKnexConfig, {
+      connection: {
+        database: `${config.database}_test`,
+      },
+    });
+
+    const fixture_local = _.merge({}, defaultKnexConfig, {
+      connection: {
+        database: `${config.database}_fixture`,
+      },
+    });
+
+    // 개발 환경 설정
+    const devMasterOptions = config.environments?.development;
+    const devSlaveOptions = config.environments?.development_slave;
+    const development_master = _.merge({}, defaultKnexConfig, devMasterOptions);
+    const development_slave = _.merge(
+      {},
+      defaultKnexConfig,
+      devMasterOptions,
+      devSlaveOptions
+    );
+    const fixture_remote = _.merge({}, defaultKnexConfig, devMasterOptions, {
+      connection: {
+        database: `${config.database}_fixture`,
+      },
+    });
+
+    // 프로덕션 환경 설정
+    const prodMasterOptions = config.environments?.production ?? {};
+    const prodSlaveOptions = config.environments?.production_slave ?? {};
+    const production_master = _.merge({}, defaultKnexConfig, prodMasterOptions);
+    const production_slave = _.merge(
+      {},
+      defaultKnexConfig,
+      prodMasterOptions,
+      prodSlaveOptions
+    );
+
+    return {
+      test,
+      fixture_local,
+      fixture_remote,
+      development_master,
+      development_slave,
+      production_master,
+      production_slave,
+    };
+  }
+
+  /**
+   * keys에 해당하는 설정들을 중복없이 가져옵니다. (host/port/database가 같은 설정은 중복으로 처리합니다.)
+   */
+  getUniqueConfigs(keys: (keyof SonamuKnexDBConfig)[]) {
+    const targets = keys.map((key) => ({
+      connKey: key,
+      options: this.fullConfig[key as keyof SonamuKnexDBConfig],
+    }));
+
+    return _.uniqBy(targets, ({ options }) => {
+      const conn = options.connection as Knex.ConnectionConfig & {
+        port?: number;
+      };
+
+      return `${conn.host ?? "localhost"}:${conn.port ?? 3306}/${
+        conn.database
+      }`;
+    });
+  }
+}