sonamu 0.4.13 → 0.5.0

package/src/database/db.ts

@@ -1,23 +1,193 @@
+export type DBPreset = "w" | "r";
+import knex, { Knex } from "knex";
 import path from "path";
-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();
+import _ from "lodash";
+import { Sonamu } from "../api";
+import { ServiceUnavailableException } from "../exceptions/so-exceptions";
+import { AsyncLocalStorage } from "async_hooks";
+import { TransactionContext } from "./transaction-context";
+
+type MySQLConfig = Omit<Knex.Config, "connection"> & {
+  connection?: Knex.MySql2ConnectionConfig;
+};
+
+export type SonamuDBBaseConfig = {
+  // 기본 데이터베이스 이름
+  database: string;
+
+  // 모든 환경에 적용될 기본 Knex 옵션
+  defaultOptions?: MySQLConfig;
+
+  // 환경별 설정
+  environments?: {
+    development?: MySQLConfig;
+    development_slave?: MySQLConfig;
+    production?: MySQLConfig;
+    production_slave?: MySQLConfig;
+  };
+};
+
+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;
+
+  public transactionStorage = new AsyncLocalStorage<TransactionContext>();
+
+  public runWithTransaction<T>(callback: () => Promise<T>): Promise<T> {
+    return this.transactionStorage.run(new TransactionContext(), callback);
+  }
+
+  public getTransactionContext(): TransactionContext {
+    return this.transactionStorage.getStore() ?? new TransactionContext();
+  }
+
+  async readKnexfile(): Promise<SonamuDBConfig> {
+    const dbConfigPath: string = path.join(
+      Sonamu.apiRootPath,
+      "/dist/configs/db.js"
+    );
+    try {
+      const knexfileModule = await import(dbConfigPath);
+      const config =
+        knexfileModule.default?.default ??
+        knexfileModule.default ??
+        knexfileModule;
+      return this.generateDBConfig(config);
+    } catch {}
+
+    throw new ServiceUnavailableException(
+      `다음 경로에서 DB설정 파일을 찾을 수 없습니다: ${dbConfigPath}. 먼저 빌드(yarn build)를 수행해주세요.`
+    );
+  }
+
+  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;
+    }
+  }
+
+  private generateDBConfig(config: SonamuDBBaseConfig): SonamuDBConfig {
+    const defaultKnexConfig: Partial<MySQLConfig> = _.merge(
+      {
+        client: "mysql2",
+        pool: {
+          min: 1,
+          max: 5,
+        },
+        migrations: {
+          extension: "js",
+          directory: "./dist/migrations",
+        },
+        connection: {
+          database: config.database,
+          ...config.defaultOptions?.connection,
+        },
+      },
+      config.defaultOptions
+    );
+
+    // 로컬 환경 설정
+    const test: MySQLConfig = _.merge({}, defaultKnexConfig, {
+      connection: {
+        database: `${config.database}_test`,
+        ...config.defaultOptions?.connection,
+      },
+    });
+
+    const fixture_local = _.merge({}, defaultKnexConfig, {
+      connection: {
+        database: `${config.database}_fixture_local`,
+        ...config.defaultOptions?.connection,
+      },
+    });
+
+    // 개발 환경 설정
+    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_remote`,
+        ...config.defaultOptions?.connection,
+      },
+    });
+
+    // 프로덕션 환경 설정
+    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,
+    };
   }
-  throw new Error("지원하지 않는 DB 클라이언트입니다.");
-})();
+}
+export const DB = new DBClass();

package/src/database/{drivers/knex/plugins → knex-plugins}/knex-on-duplicate-update.ts

@@ -42,4 +42,4 @@ export function attachOnDuplicateUpdate() {
   } catch {
     // ignored
   }
-}
+}

package/src/database/puri-wrapper.ts

@@ -0,0 +1,129 @@
+import { Knex } from "knex";
+import { Puri } from "./puri";
+import { UBRef, UpsertBuilder } from "./upsert-builder";
+import { DatabaseSchemaExtend } from "../types/types";
+import chalk from "chalk";
+import { DBPreset } from "./db";
+
+type TableName<DBSchema extends DatabaseSchemaExtend> = Extract<
+  keyof DBSchema,
+  string
+>;
+
+export type TransactionalOptions = {
+  isolation?: Exclude<Knex.IsolationLevels, "snapshot">; // snapshot: mssql only
+  dbPreset?: DBPreset;
+  readOnly?: boolean;
+};
+
+export class PuriWrapper<
+  DBSchema extends DatabaseSchemaExtend = DatabaseSchemaExtend
+> {
+  constructor(public knex: Knex, public upsertBuilder: UpsertBuilder) {}
+
+  raw(sql: string): Knex.Raw {
+    return this.knex.raw(sql);
+  }
+  // 기존: 테이블로 시작
+  table<TTable extends TableName<DBSchema>>(
+    tableName: TTable
+  ): Puri<DBSchema, TTable> {
+    return new Puri(this.knex, tableName as any);
+  }
+
+  // 새로 추가: 서브쿼리로 시작
+  fromSubquery<TSubResult, TAlias extends string>(
+    subquery: Puri<DBSchema, any, any, TSubResult, any>,
+    alias: TAlias extends string ? TAlias : never
+  ): Puri<DBSchema, TAlias, TSubResult, TSubResult, {}> {
+    return new Puri(this.knex, subquery, alias);
+  }
+
+  async transaction<T>(
+    callback: (trx: PuriWrapper) => Promise<T>,
+    options: TransactionalOptions = {}
+  ): Promise<T> {
+    const { isolation, readOnly } = options;
+
+    return this.knex.transaction(
+      async (trx) => {
+        return callback(new PuriWrapper(trx, this.upsertBuilder));
+      },
+      { isolationLevel: isolation, readOnly }
+    );
+  }
+
+  ubRegister<TTable extends TableName<DBSchema>>(
+    tableName: TTable,
+    row: Partial<{
+      [K in keyof DBSchema[TTable]]: DBSchema[TTable][K] | UBRef;
+    }>
+  ): UBRef {
+    return this.upsertBuilder.register(tableName, row);
+  }
+
+  ubUpsert(
+    tableName: TableName<DBSchema>,
+    chunkSize?: number
+  ): Promise<number[]> {
+    return this.upsertBuilder.upsert(this.knex, tableName, chunkSize);
+  }
+
+  ubInsertOnly(
+    tableName: TableName<DBSchema>,
+    chunkSize?: number
+  ): Promise<number[]> {
+    return this.upsertBuilder.insertOnly(this.knex, tableName, chunkSize);
+  }
+
+  ubUpsertOrInsert(
+    tableName: TableName<DBSchema>,
+    mode: "upsert" | "insert",
+    chunkSize?: number
+  ): Promise<number[]> {
+    return this.upsertBuilder.upsertOrInsert(
+      this.knex,
+      tableName,
+      mode,
+      chunkSize
+    );
+  }
+
+  ubUpdateBatch(
+    tableName: TableName<DBSchema>,
+    options?: { chunkSize?: number; where?: string | string[] }
+  ): Promise<void> {
+    return this.upsertBuilder.updateBatch(this.knex, tableName, options);
+  }
+
+  // 트랜잭션 연결 테스트용
+  async debugTransaction() {
+    const info = await this.getTransactionInfo();
+    console.log(`${chalk.cyan("[Puri Transaction]")} ${chalk.magenta(info)}`);
+  }
+
+  private async getTransactionInfo(): Promise<string> {
+    // 연결 ID 조회
+    const [connectionIdRows] = await this.knex.raw(
+      `SELECT CONNECTION_ID() as connection_id`
+    );
+    const connectionId = connectionIdRows[0].connection_id;
+
+    // 트랜잭션 정보 조회
+    const [trxRows] = await this.knex.raw(`
+        SELECT STATE, ISOLATION_LEVEL, THREAD_ID, EVENT_ID
+        FROM performance_schema.events_transactions_current
+        WHERE THREAD_ID = 
+          (SELECT THREAD_ID
+          FROM performance_schema.threads 
+          WHERE PROCESSLIST_ID = CONNECTION_ID())
+      `);
+
+    if (trxRows.length > 0 && trxRows[0].STATE !== "COMMITTED") {
+      const trx = trxRows[0];
+      return `In Transaction, ConnID: ${connectionId}, ThreadID: ${trx.THREAD_ID}, EventID: ${trx.EVENT_ID}, InnoDB TRX: ${trx.STATE}(${trx.ISOLATION_LEVEL})`;
+    } else {
+      return `Not in Transaction, ConnID: ${connectionId}`;
+    }
+  }
+}