sonamu 0.2.54 → 0.4.1

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-manager.ts

@@ -44,7 +44,7 @@ class EntityManagerClass {
       glob.glob(path.resolve(pathPattern!), (_err, files) => {
         Promise.all(
           files.map(async (file) => {
-            this.register(JSON.parse(fs.readFileSync(file).toString()));
+            await this.register(JSON.parse(fs.readFileSync(file).toString()));
           })
         ).then(() => {
           resolve("ok");
@@ -63,18 +63,22 @@ class EntityManagerClass {
 
     const sonamuPath = path.join(
       Sonamu.apiRootPath,
-      "dist/application/sonamu.generated.js"
+      `dist/application/sonamu.generated.js?t=${Date.now()}`
     );
-    if (require.cache[sonamuPath]) {
+    // CJS
+    if (require?.cache && require.cache[sonamuPath]) {
       delete require.cache[sonamuPath];
     }
 
-    return this.autoload(doSilent);
+    return await this.autoload(doSilent);
   }
 
-  register(json: EntityJson): void {
+  async register(json: EntityJson): Promise<void> {
     const entity = new Entity(json);
+    await entity.registerModulePaths();
+    entity.registerTableSpecs();
     this.entities.set(json.id, entity);
+    // console.debug(chalk.cyan(`register :: ${entity.id}`));
   }
 
   get(entityId: string): Entity {

package/src/entity/entity-utils.ts

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

package/src/entity/entity.ts

@@ -133,9 +133,6 @@ export class Entity {
       fs: inflection.dasherize(inflection.underscore(id)).toLowerCase(),
       module: id,
     };
-
-    this.registerModulePaths();
-    this.registerTableSpecs();
   }
 
   /*
@@ -544,7 +541,7 @@ export class Entity {
       .filter(nonNullable);
   }
 
-  registerModulePaths() {
+  async registerModulePaths() {
     const basePath = `${this.names.parentFs}`;
 
     // base-scheme
@@ -579,15 +576,14 @@ export class Entity {
 
     if (fs.existsSync(typesFileDistPath)) {
       const importPath = path.relative(__dirname, typesFileDistPath);
-      import(importPath).then((t) => {
-        this.types = Object.keys(t).reduce((result, key) => {
-          EntityManager.setModulePath(key, typesModulePath);
-          return {
-            ...result,
-            [key]: t[key],
-          };
-        }, {});
-      });
+      const t = await import(importPath);
+      this.types = Object.keys(t).reduce((result, key) => {
+        EntityManager.setModulePath(key, typesModulePath);
+        return {
+          ...result,
+          [key]: t[key],
+        };
+      }, {});
     }
   }