sonamu 0.3.1 → 0.4.2

package/src/database/types.ts

@@ -0,0 +1,117 @@
+import { Knex } from "knex";
+import {
+  FileMigrationProviderProps,
+  Kysely,
+  MysqlDialectConfig,
+  ReferenceExpression,
+  SelectQueryBuilder,
+} from "kysely";
+import { KnexClient } from "./drivers/knex/client";
+import { KyselyClient } from "./drivers/kysely/client";
+import { PoolOptions } from "mysql2";
+
+export type DBPreset = "w" | "r";
+
+export type DatabaseDriver = keyof DriverSpec;
+/**
+ * core: 실제 데이터베이스 라이브러리 인스턴스
+ * adapter: Sonamu의 래퍼 클라이언트 구현체
+ * queryBuilder: 쿼리빌더 인스턴스
+ * table/column: 테이블과 컬럼 타입 정보
+ */
+export interface DriverSpec {
+  knex: {
+    core: Knex;
+    adapter: KnexClient;
+    queryBuilder: Knex.QueryBuilder;
+    table: string;
+    column: string;
+  };
+  kysely: {
+    core: Kysely<Database>;
+    adapter: KyselyClient;
+    queryBuilder: SelectQueryBuilder<Database, keyof Database, {}>;
+    table: keyof Database;
+    column: ReferenceExpression<Database, keyof Database>;
+  };
+}
+
+export type WhereClause = [string, string, any];
+
+export interface DatabaseClient<T extends DatabaseDriver> {
+  from(table: string): DriverSpec[T]["adapter"];
+  innerJoin(table: string, k1: string, k2: string): DriverSpec[T]["adapter"];
+  leftJoin(table: string, k1: string, k2: string): DriverSpec[T]["adapter"];
+  select(columns: string | string[]): DriverSpec[T]["adapter"];
+  where(o: WhereClause): DriverSpec[T]["adapter"];
+  orWhere(o: WhereClause | WhereClause[]): DriverSpec[T]["adapter"];
+  insert(table: string, data: Record<string, any>): Promise<void>;
+  first(): DriverSpec[T]["adapter"];
+  execute(): Promise<any[]>;
+
+  raw<R>(query: string, bindings?: any[]): Promise<R[]>;
+  truncate(table: string): Promise<void>;
+  trx<T>(callback: (trx: any) => Promise<T>): Promise<T>;
+  destroy(): Promise<void>;
+
+  getMigrations(): Promise<string[]>;
+}
+
+//
+
+export type Environment =
+  | "development"
+  | "development_slave"
+  | "production"
+  | "production_slave";
+type EnvironmentConfigs<T> = {
+  [K in Environment]?: Partial<T>;
+};
+
+// Knex 설정을 위한 타입
+export type KnexConfig = Knex.Config & {
+  connection: Knex.MySql2ConnectionConfig;
+};
+export type KnexBaseConfig = {
+  client: "knex";
+  database: string;
+  defaultOptions?: Partial<KnexConfig>;
+  environments?: EnvironmentConfigs<KnexConfig>;
+};
+
+// Kysely 설정을 위한 타입
+export type KyselyConfig = PoolOptions &
+  Pick<MysqlDialectConfig, "onCreateConnection"> & {
+    migration?: FileMigrationProviderProps;
+  };
+export type KyselyBaseConfig = {
+  client: "kysely";
+  database: string;
+  defaultOptions: KyselyConfig;
+  environments?: EnvironmentConfigs<KyselyConfig>;
+  types?: {
+    enabled?: boolean; // 인터페이스 자동 생성 활성화 (기본값: true)
+    outDir?: string; // 생성될 파일 경로 (기본값: src/typings)
+    fileName?: string; // 생성될 파일명 (기본값: database.types.ts)
+  };
+};
+// export type SonamuDBBaseConfig = KnexBaseConfig | KyselyBaseConfig;
+export type SonamuDBBaseConfig<
+  T extends "knex" | "kysely" = "knex" | "kysely",
+> = T extends "knex" ? KnexBaseConfig : KyselyBaseConfig;
+
+export type SonamuDBFullConfig<T extends KnexConfig | KyselyConfig> = {
+  development_master: T;
+  development_slave: T;
+  test: T;
+  fixture_local: T;
+  fixture_remote: T;
+  production_master: T;
+  production_slave: T;
+};
+export type SonamuKnexDBConfig = SonamuDBFullConfig<KnexConfig>;
+export type SonamuKyselyDBConfig = SonamuDBFullConfig<KyselyConfig>;
+export type SonamuDBConfig = SonamuKnexDBConfig | SonamuKyselyDBConfig;
+
+export interface DatabaseExtend {}
+export type Database = DatabaseExtend & {};

package/src/database/upsert-builder.ts

@@ -1,9 +1,12 @@
 import { v4 as uuidv4 } from "uuid";
 import _ from "lodash";
 import { Knex } from "knex";
+import { Kysely } from "kysely";
 import { EntityManager } from "../entity/entity-manager";
 import { nonNullable } from "../utils/utils";
 import { RowWithId, batchUpdate } from "./_batch_update";
+import { Database, DatabaseDriver, DriverSpec } from "./types";
+import { DB } from "./db";
 
 type TableData = {
   references: Set<string>;
@@ -25,7 +28,7 @@ export function isRefField(field: any): field is UBRef {
   );
 }
 
-export class UpsertBuilder {
+export class UpsertBuilder<D extends DatabaseDriver> {
   tables: Map<string, TableData>;
   constructor() {
     this.tables = new Map();
@@ -58,7 +61,7 @@ export class UpsertBuilder {
   }
 
   register<T extends string>(
-    tableName: string,
+    tableName: DriverSpec[D]["table"],
     row: {
       [key in T]?:
         | UBRef
@@ -145,23 +148,23 @@ export class UpsertBuilder {
   }
 
   async upsert(
-    wdb: Knex,
-    tableName: string,
+    wdb: DriverSpec[D]["core"],
+    tableName: DriverSpec[D]["table"],
     chunkSize?: number
   ): Promise<number[]> {
     return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
   }
   async insertOnly(
-    wdb: Knex,
-    tableName: string,
+    wdb: DriverSpec[D]["core"],
+    tableName: DriverSpec[D]["table"],
     chunkSize?: number
   ): Promise<number[]> {
     return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
   }
 
   async upsertOrInsert(
-    wdb: Knex,
-    tableName: string,
+    _wdb: DriverSpec[D]["core"],
+    tableName: DriverSpec[D]["table"],
     mode: "upsert" | "insert",
     chunkSize?: number
   ): Promise<number[]> {
@@ -186,6 +189,8 @@ export class UpsertBuilder {
       throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
     }
 
+    const wdb = DB.toClient(_wdb);
+
     // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출
     const { references, refTables } = Array.from(this.tables).reduce(
       (r, [, table]) => {
@@ -221,18 +226,20 @@ export class UpsertBuilder {
     const uuidMap = new Map<string, any>();
 
     for (const chunk of chunks) {
-      const q = wdb.insert(chunk).into(tableName);
       if (mode === "insert") {
-        await q;
+        await wdb.insert(tableName, chunk);
       } else if (mode === "upsert") {
-        await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
+        await wdb.upsert(tableName, chunk);
+        // await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
       }
 
       // upsert된 row들을 다시 조회하여 uuidMap에 저장
       const uuids = chunk.map((row) => row.uuid);
-      const upsertedRows = await wdb(tableName)
+      const upsertedRows = await wdb
+        .from(tableName)
         .select(_.uniq(["uuid", "id", ...extractFields]))
-        .whereIn("uuid", uuids);
+        .where(["uuid", "in", uuids])
+        .execute();
       upsertedRows.forEach((row: any) => {
         uuidMap.set(row.uuid, row);
       });
@@ -264,7 +271,7 @@ export class UpsertBuilder {
     if (selfRefRows.length > 0) {
       // 처리된 데이터를 제외하고 다시 upsert
       table.rows = selfRefRows;
-      const selfRefIds = await this.upsert(wdb, tableName, chunkSize);
+      const selfRefIds = await this.upsert(_wdb, tableName, chunkSize);
       allIds.push(...selfRefIds);
     }
 
@@ -272,11 +279,11 @@ export class UpsertBuilder {
   }
 
   async updateBatch(
-    wdb: Knex,
-    tableName: string,
+    wdb: Knex | Kysely<Database>,
+    tableName: DriverSpec[D]["table"],
     options?: {
       chunkSize?: number;
-      where?: string | string[];
+      where?: DriverSpec[D]["column"] | DriverSpec[D]["column"][];
     }
   ): Promise<void> {
     options = _.defaults(options, {
@@ -300,6 +307,12 @@ export class UpsertBuilder {
       return row as RowWithId<string>;
     });
 
-    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);
+    await batchUpdate(
+      DB.toClient(wdb),
+      tableName,
+      whereColumns as string[],
+      rows,
+      options.chunkSize
+    );
   }
 }

package/src/entity/entity-utils.ts

@@ -155,7 +155,7 @@ function dateTime(
   }
   return {
     name,
-    type: "dateTime",
+    type: "datetime",
     ...option,
   };
 }