sonamu 0.4.13 → 0.5.0

package/src/database/base-model.abstract.ts

@@ -1,97 +0,0 @@
-import { DateTime } from "luxon";
-import _ from "lodash";
-import { Knex } from "knex";
-import { RawBuilder } from "kysely";
-import { BaseListParams } from "../utils/model";
-import { DBPreset, DatabaseDriver, DriverSpec } from "./types";
-import { SubsetQuery } from "../types/types";
-
-export abstract class BaseModelAbstract<D extends DatabaseDriver> {
-  public modelName: string = "Unknown";
-
-  abstract runSubsetQuery<T extends BaseListParams, U extends string>(options: {
-    params: T;
-    baseTable?: string;
-    subset: U;
-    subsetQuery: SubsetQuery;
-    build: (buildParams: {
-      qb: DriverSpec[D]["queryBuilder"];
-      db: DriverSpec[D]["adapter"];
-      select: SubsetQuery["select"];
-      joins: SubsetQuery["joins"];
-      virtual: string[];
-    }) => any;
-    debug?: boolean | "list" | "count";
-    db?: DriverSpec[D]["adapter"];
-    optimizeCountQuery?: boolean;
-  }): Promise<{
-    rows: any[];
-    total?: number;
-    subsetQuery: SubsetQuery;
-    qb: DriverSpec[D]["queryBuilder"];
-  }>;
-  abstract getDB(which: DBPreset): DriverSpec[D]["adapter"];
-  abstract destroy(): Promise<void>;
-  abstract useLoaders(
-    db: DriverSpec[D]["adapter"],
-    rows: any[],
-    loaders: SubsetQuery["loaders"]
-  ): Promise<any[]>;
-  abstract getJoinClause(
-    db: DriverSpec[D]["adapter"],
-    join: SubsetQuery["joins"][number]
-  ): string | Knex.Raw<any> | RawBuilder<unknown>;
-
-  myNow(timestamp?: number): string {
-    const dt: DateTime =
-      timestamp === undefined
-        ? DateTime.local()
-        : DateTime.fromSeconds(timestamp);
-    return dt.toFormat("yyyy-MM-dd HH:mm:ss");
-  }
-
-  hydrate<T>(rows: T[]): T[] {
-    return rows.map((row: any) => {
-      // nullable relation인 경우 관련된 필드가 전부 null로 생성되는 것 방지하는 코드
-      const nestedKeys = Object.keys(row).filter((key) => key.includes("__"));
-      const groups = _.groupBy(nestedKeys, (key) => key.split("__")[0]);
-      const nullKeys = Object.keys(groups).filter(
-        (key) =>
-          groups[key].length > 1 &&
-          groups[key].every((field) => row[field] === null)
-      );
-
-      const hydrated = Object.keys(row).reduce((r, field) => {
-        if (!field.includes("__")) {
-          if (Array.isArray(row[field]) && _.isObject(row[field][0])) {
-            r[field] = this.hydrate(row[field]);
-            return r;
-          } else {
-            r[field] = row[field];
-            return r;
-          }
-        }
-
-        const parts = field.split("__");
-        const objPath =
-          parts[0] +
-          parts
-            .slice(1)
-            .map((part) => `[${part}]`)
-            .join("");
-        _.set(
-          r,
-          objPath,
-          row[field] && Array.isArray(row[field]) && _.isObject(row[field][0])
-            ? this.hydrate(row[field])
-            : row[field]
-        );
-
-        return r;
-      }, {} as any);
-      nullKeys.map((nullKey) => (hydrated[nullKey] = null));
-
-      return hydrated;
-    });
-  }
-}

package/src/database/db.abstract.ts

@@ -1,75 +0,0 @@
-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/drivers/knex/base-model.ts

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

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

@@ -1,232 +0,0 @@
-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);
-  }
-
-  public 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`,
-        },
-      },
-      config.environments?.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
-      }`;
-    });
-  }
-}