sonamu 0.4.14 → 0.5.0

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

@@ -1,89 +0,0 @@
-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

@@ -1,309 +0,0 @@
-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

@@ -1,238 +0,0 @@
-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);
-  }
-
-  public 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}`
-    );
-  }
-}