sonamu 0.4.14 → 0.5.1

package/src/database/base-model.ts

@@ -1,28 +1,216 @@
-// base-model.ts
 import { DateTime } from "luxon";
-import _ from "lodash";
-import SqlParser from "node-sql-parser";
-import chalk from "chalk";
+import { Knex } from "knex";
+import { chunk, groupBy, isObject, omit, set, uniq } from "lodash";
+import { DBPreset, DB } from "./db";
+import { isCustomJoinClause, type SubsetQuery } from "../types/types";
+import type { BaseListParams } from "../utils/model";
 import inflection from "inflection";
-import { BaseListParams } from "../utils/model";
-import { DBPreset, DriverSpec, DatabaseDriver } from "./types";
-import { SubsetQuery } from "../types/types";
+import chalk from "chalk";
+import { UpsertBuilder } from "./upsert-builder";
+import SqlParser from "node-sql-parser";
 import { getTableName, getTableNamesFromWhere } from "../utils/sql-parser";
-import { DB } from "./db";
+import { PuriWrapper } from "./puri-wrapper";
 
-export abstract class BaseModelClassAbstract<D extends DatabaseDriver> {
+export class BaseModelClass {
   public modelName: string = "Unknown";
 
-  protected abstract applyJoins(
-    qb: DriverSpec[D]["adapter"],
-    joins: SubsetQuery["joins"]
-  ): DriverSpec[D]["adapter"];
-  protected abstract executeCountQuery(
-    qb: DriverSpec[D]["queryBuilder"]
-  ): Promise<number>;
+  /* DB 인스턴스 get, destroy */
+  getDB(which: DBPreset): Knex {
+    return DB.getDB(which);
+  }
+
+  getPuri(which: DBPreset): PuriWrapper {
+    // 트랜잭션 컨텍스트에서 트랜잭션 획득
+    const trx = DB.getTransactionContext().getTransaction(which);
+    if (trx) {
+      return trx;
+    }
+
+    // 트랜잭션이 없으면 새로운 PuriWrapper 반환
+    const db = this.getDB(which);
+    return new PuriWrapper(db, this.getUpsertBuilder());
+  }
+
+  async destroy() {
+    return DB.destroy();
+  }
+
+  myNow(timestamp?: number): string {
+    const dt: DateTime =
+      timestamp === undefined
+        ? DateTime.local()
+        : DateTime.fromSeconds(timestamp);
+    return dt.toFormat("yyyy-MM-dd HH:mm:ss");
+  }
+
+  async getInsertedIds(
+    wdb: Knex,
+    rows: any[],
+    tableName: string,
+    unqKeyFields: string[],
+    chunkSize: number = 500
+  ) {
+    if (!wdb) {
+      wdb = this.getDB("w");
+    }
+
+    let unqKeys: string[];
+    let whereInField: any, selectField: string;
+    if (unqKeyFields.length > 1) {
+      whereInField = wdb.raw(`CONCAT_WS('_', '${unqKeyFields.join(",")}')`);
+      selectField = `${whereInField} as tmpUid`;
+      unqKeys = rows.map((row) =>
+        unqKeyFields.map((field) => row[field]).join("_")
+      );
+    } else {
+      whereInField = unqKeyFields[0];
+      selectField = unqKeyFields[0];
+      unqKeys = rows.map((row) => row[unqKeyFields[0]]);
+    }
+    const chunks = chunk(unqKeys, chunkSize);
+
+    let resultIds: number[] = [];
+    for (let chunk of chunks) {
+      const dbRows = await wdb(tableName)
+        .select("id", wdb.raw(selectField))
+        .whereIn(whereInField, chunk);
+      resultIds = resultIds.concat(
+        dbRows.map((dbRow: any) => parseInt(dbRow.id))
+      );
+    }
+
+    return resultIds;
+  }
+
+  async useLoaders(db: Knex, rows: any[], loaders: SubsetQuery["loaders"]) {
+    if (loaders.length === 0) {
+      return rows;
+    }
+
+    for (let loader of loaders) {
+      let subQ: any;
+      let subRows: any[];
+      let toCol: string;
+
+      const fromIds = rows.map((row) => row[loader.manyJoin.idField]);
+
+      if (loader.manyJoin.through === undefined) {
+        // HasMany
+        const idColumn = `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`;
+        subQ = db(loader.manyJoin.toTable)
+          .whereIn(idColumn, fromIds)
+          .select([...loader.select, idColumn]);
+
+        // HasMany에서 OneJoin이 있는 경우
+        loader.oneJoins.map((join) => {
+          if (join.join == "inner") {
+            subQ.innerJoin(
+              `${join.table} as ${join.as}`,
+              this.getJoinClause(db, join)
+            );
+          } else if (join.join == "outer") {
+            subQ.leftOuterJoin(
+              `${join.table} as ${join.as}`,
+              this.getJoinClause(db, join)
+            );
+          }
+        });
+        toCol = loader.manyJoin.toCol;
+      } else {
+        // ManyToMany
+        const idColumn = `${loader.manyJoin.through.table}.${loader.manyJoin.through.fromCol}`;
+        subQ = db(loader.manyJoin.through.table)
+          .join(
+            loader.manyJoin.toTable,
+            `${loader.manyJoin.through.table}.${loader.manyJoin.through.toCol}`,
+            `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`
+          )
+          .whereIn(idColumn, fromIds)
+          .select(uniq([...loader.select, idColumn]));
+
+        // ManyToMany에서 OneJoin이 있는 경우
+        loader.oneJoins.map((join) => {
+          if (join.join == "inner") {
+            subQ.innerJoin(
+              `${join.table} as ${join.as}`,
+              this.getJoinClause(db, join)
+            );
+          } else if (join.join == "outer") {
+            subQ.leftOuterJoin(
+              `${join.table} as ${join.as}`,
+              this.getJoinClause(db, join)
+            );
+          }
+        });
+        toCol = loader.manyJoin.through.fromCol;
+      }
+      subRows = await subQ;
+
+      if (loader.loaders) {
+        // 추가 -Many 케이스가 있는 경우 recursion 처리
+        subRows = await this.useLoaders(db, subRows, loader.loaders);
+      }
+
+      // 불러온 row들을 참조ID 기준으로 분류 배치
+      const subRowGroups = groupBy(subRows, toCol);
+      rows = rows.map((row) => {
+        row[loader.as] = (subRowGroups[row[loader.manyJoin.idField]] ?? []).map(
+          (r) => omit(r, toCol)
+        );
+        return row;
+      });
+    }
+    return rows;
+  }
 
-  abstract getDB(which: DBPreset): DriverSpec[D]["core"];
-  abstract destroy(): Promise<void>;
+  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 ||
+              (Array.isArray(row[field]) && row[field].length === 0)
+          )
+      );
+
+      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;
+    });
+  }
 
   async runSubsetQuery<T extends BaseListParams, U extends string>({
     params,
@@ -30,6 +218,7 @@ export abstract class BaseModelClassAbstract<D extends DatabaseDriver> {
     subset,
     subsetQuery,
     build,
+    afterBuild,
     debug,
     db: _db,
     optimizeCountQuery,
@@ -38,265 +227,186 @@ export abstract class BaseModelClassAbstract<D extends DatabaseDriver> {
     params: T;
     subsetQuery: SubsetQuery;
     build: (buildParams: {
-      qb: DriverSpec[D]["queryBuilder"];
-      db: DriverSpec[D]["core"];
-      select: SubsetQuery["select"];
+      qb: Knex.QueryBuilder;
+      db: Knex;
+      select: (string | Knex.Raw)[];
       joins: SubsetQuery["joins"];
       virtual: string[];
-    }) => DriverSpec[D]["queryBuilder"];
-    baseTable?: DriverSpec[D]["table"];
+    }) => Knex.QueryBuilder;
+    afterBuild?: (buildParams: {
+      qb: Knex.QueryBuilder;
+      db: Knex;
+      select: (string | Knex.Raw)[];
+      joins: SubsetQuery["joins"];
+      virtual: string[];
+    }) => Knex.QueryBuilder;
+    baseTable?: string;
     debug?: boolean | "list" | "count";
-    db?: DriverSpec[D]["core"];
+    db?: Knex;
     optimizeCountQuery?: boolean;
   }): Promise<{
     rows: any[];
-    total?: number;
+    total?: number | undefined;
     subsetQuery: SubsetQuery;
-    qb: DriverSpec[D]["queryBuilder"];
+    qb: Knex.QueryBuilder;
   }> {
-    const db = _db ?? DB.getDB(subset.startsWith("A") ? "w" : "r");
-    const dbClient = DB.toClient(db);
+    const db = _db ?? this.getDB(subset.startsWith("A") ? "w" : "r");
     baseTable =
       baseTable ?? inflection.pluralize(inflection.underscore(this.modelName));
     const queryMode =
       params.queryMode ?? (params.id !== undefined ? "list" : "both");
 
     const { select, virtual, joins, loaders } = subsetQuery;
-    const _qb = build({
-      qb: dbClient.from(baseTable).qb,
+    const qb = build({
+      qb: db.from(baseTable),
       db,
       select,
       joins,
       virtual,
     });
-    dbClient.qb = _qb;
-    const qb = dbClient;
 
+    const applyJoinClause = (
+      qb: Knex.QueryBuilder,
+      joins: SubsetQuery["joins"]
+    ) => {
+      joins.map((join) => {
+        if (join.join == "inner") {
+          qb.innerJoin(
+            `${join.table} as ${join.as}`,
+            this.getJoinClause(db, join)
+          );
+        } else if (join.join == "outer") {
+          qb.leftOuterJoin(
+            `${join.table} as ${join.as}`,
+            this.getJoinClause(db, join)
+          );
+        }
+      });
+    };
+
+    // countQuery
     const total = await (async () => {
-      if (queryMode === "list") return undefined;
+      if (queryMode === "list") {
+        return undefined;
+      }
 
-      const clonedQb = qb
-        .clone()
-        .clearQueryParts(["order", "offset", "limit"])
-        .clearSelect()
-        .select(`${baseTable}.id`);
+      const clonedQb = qb.clone().clear("order").clear("offset").clear("limit");
       const parser = new SqlParser.Parser();
 
+      // optmizeCountQuery가 true인 경우 다른 clause에 영향을 주지 않는 모든 join을 제외함
       if (optimizeCountQuery) {
-        const parsedQuery = parser.astify(clonedQb.sql);
+        const parsedQuery = parser.astify(clonedQb.toQuery());
         const tables = getTableNamesFromWhere(parsedQuery);
-        const needToJoin = _.uniq(
+        // where절에 사용되는 테이블의 조인을 위해 사용되는 테이블
+        const needToJoin = uniq(
           tables.flatMap((table) =>
             table.split("__").map((t) => inflection.pluralize(t))
           )
         );
-
-        this.applyJoins(
+        applyJoinClause(
           clonedQb,
           joins.filter((j) => needToJoin.includes(j.table))
         );
       } else {
-        this.applyJoins(clonedQb, joins);
+        applyJoinClause(clonedQb, joins);
       }
 
-      const parsedQuery = parser.astify(clonedQb.sql);
-      const q = Array.isArray(parsedQuery) ? parsedQuery[0] : parsedQuery;
+      const processedQb =
+        afterBuild?.({
+          qb: clonedQb,
+          db,
+          select,
+          joins,
+          virtual,
+        }) ?? clonedQb;
 
+      const parsedQuery = parser.astify(processedQb.toQuery());
+      const q = Array.isArray(parsedQuery) ? parsedQuery[0] : parsedQuery;
       if (q.type !== "select") {
         throw new Error("Invalid query");
       }
 
-      const countColumn = `${getTableName(q.columns[0].expr)}.${q.columns[0].expr.column}`;
-      clonedQb.clearSelect().count(countColumn, "total").first();
-      if (q.distinct) {
-        clonedQb.distinct(countColumn);
-      }
-
+      const countQuery =
+        q.distinct !== null
+          ? clonedQb
+              .clear("select")
+              .select(
+                db.raw(
+                  `COUNT(DISTINCT \`${getTableName(q.columns[0].expr)}\`.\`${q.columns[0].expr.column}\`) as total`
+                )
+              )
+              .first()
+          : clonedQb.clear("select").count("*", { as: "total" }).first();
+      const countRow: { total?: number } = await countQuery;
+
+      // debug: countQuery
       if (debug === true || debug === "count") {
-        console.debug("DEBUG: count query", chalk.blue(clonedQb.sql));
+        console.debug(
+          "DEBUG: count query",
+          chalk.blue(countQuery.toQuery().toString())
+        );
       }
 
-      const [{ total }] = await clonedQb.execute();
-      return total;
+      return countRow?.total ?? 0;
     })();
 
+    // listQuery
     const rows = await (async () => {
-      if (queryMode === "count") return [];
-
-      let listQb = qb;
-      if (params.num !== 0) {
-        listQb = listQb
-          .limit(params.num!)
-          .offset(params.num! * (params.page! - 1));
+      if (queryMode === "count") {
+        return [];
       }
 
-      listQb.select(select);
-      listQb = this.applyJoins(listQb, joins);
-
-      if (debug === true || debug === "list") {
-        console.debug("DEBUG: list query", chalk.blue(listQb.sql));
+      // limit, offset
+      if (params.num !== 0) {
+        qb.limit(params.num!);
+        qb.offset(params.num! * (params.page! - 1));
       }
 
-      let rows = await listQb.execute();
-      rows = await this.useLoaders(dbClient, rows, loaders);
-      return this.hydrate(rows);
-    })();
-
-    return {
-      rows,
-      total,
-      subsetQuery,
-      qb: dbClient.qb,
-    };
-  }
-
-  async useLoaders(
-    db: DriverSpec[D]["adapter"],
-    rows: any[],
-    loaders: SubsetQuery["loaders"]
-  ): Promise<any[]> {
-    if (loaders.length === 0) return rows;
-
-    for (const loader of loaders) {
-      const fromIds = rows.map((row) => row[loader.manyJoin.idField]);
+      // select, rows
+      const clonedQb = qb.clone().select(select);
 
-      if (!fromIds.length) continue;
+      // join
+      applyJoinClause(clonedQb, joins);
 
-      let subRows: any[];
-      let toCol: string;
-
-      if (loader.manyJoin.through === undefined) {
-        // HasMany
-        const { subQ, col } = await this.buildHasManyQuery(db, loader, fromIds);
-        subRows = await subQ.execute();
-        toCol = col;
-      } else {
-        // ManyToMany
-        const { subQ, col } = await this.buildManyToManyQuery(
+      const listQuery =
+        afterBuild?.({
+          qb: clonedQb,
           db,
-          loader,
-          fromIds
-        );
-        subRows = await subQ.execute();
-        toCol = col;
-      }
-
-      if (loader.loaders) {
-        subRows = await this.useLoaders(db, subRows, loader.loaders);
-      }
+          select,
+          joins,
+          virtual,
+        }) ?? clonedQb;
 
-      // Group and assign loaded rows
-      const subRowGroups = _.groupBy(subRows, toCol);
-      rows = rows.map((row) => {
-        row[loader.as] = (subRowGroups[row[loader.manyJoin.idField]] ?? []).map(
-          (r) => _.omit(r, toCol)
+      let rows = await listQuery;
+      // debug: listQuery
+      if (debug === true || debug === "list") {
+        console.debug(
+          "DEBUG: list query",
+          chalk.blue(listQuery.toQuery().toString())
         );
-        return row;
-      });
-    }
-
-    return rows;
-  }
-
-  protected async buildHasManyQuery(
-    db: DriverSpec[D]["adapter"],
-    loader: SubsetQuery["loaders"][number],
-    fromIds: any[]
-  ) {
-    const idColumn = `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`;
-    let qb = db.from(loader.manyJoin.toTable);
-
-    db.where([idColumn, "in", fromIds]).select([...loader.select, idColumn]);
-    qb = this.applyJoins(qb, loader.oneJoins);
+      }
 
-    return {
-      subQ: qb,
-      col: loader.manyJoin.toCol,
-    };
-  }
+      rows = await this.useLoaders(db, rows, loaders);
+      rows = this.hydrate(rows);
+      return rows;
+    })();
 
-  protected async buildManyToManyQuery(
-    db: DriverSpec[D]["adapter"],
-    loader: SubsetQuery["loaders"][number],
-    fromIds: any[]
-  ) {
-    if (!loader.manyJoin.through)
-      throw new Error("Through table info missing for many-to-many relation");
-
-    const idColumn = `${loader.manyJoin.through.table}.${loader.manyJoin.through.fromCol}`;
-    let qb = db.from(loader.manyJoin.through.table);
-
-    const throughTable = loader.manyJoin.through.table;
-    const targetTable = loader.manyJoin.toTable;
-
-    qb = this.applyJoins(qb, [
-      {
-        join: "inner",
-        table: targetTable,
-        as: targetTable,
-        from: `${throughTable}.${loader.manyJoin.through.toCol}`,
-        to: `${targetTable}.${loader.manyJoin.toCol}`,
-      },
-    ]);
-
-    qb.where([idColumn, "in", fromIds]).select([...loader.select, idColumn]);
-    qb = this.applyJoins(qb, loader.oneJoins);
-
-    return {
-      subQ: qb,
-      col: loader.manyJoin.through.fromCol,
-    };
+    return { rows, total, subsetQuery, qb };
   }
 
-  myNow(timestamp?: number): string {
-    const dt: DateTime =
-      timestamp === undefined
-        ? DateTime.local()
-        : DateTime.fromSeconds(timestamp);
-    return dt.toFormat("yyyy-MM-dd HH:mm:ss");
+  getJoinClause(
+    db: Knex<any, unknown>,
+    join: SubsetQuery["joins"][number]
+  ): Knex.Raw<any> {
+    if (!isCustomJoinClause(join)) {
+      return db.raw(`${join.from} = ${join.to}`);
+    } else {
+      return db.raw(join.custom);
+    }
   }
 
-  hydrate<T>(rows: T[]): T[] {
-    return rows.map((row: any) => {
-      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]);
-          } 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.forEach((nullKey) => (hydrated[nullKey] = null));
-      return hydrated;
-    });
+  getUpsertBuilder(): UpsertBuilder {
+    return new UpsertBuilder();
   }
 }
+export const BaseModel = new BaseModelClass();