sonamu 0.3.1 → 0.4.2

package/import-to-require.js

@@ -0,0 +1,27 @@
+const fs = require("fs/promises");
+
+export const ImportToRequirePlugin = {
+  name: "import-to-require",
+  setup(build) {
+    if (build.initialOptions.define.TSUP_FORMAT === '"cjs"') {
+      // 빌드 전에 src/database/db.ts 파일을 읽어서 변환
+      build.onLoad({ filter: /database\/db.ts/ }, async (args) => {
+        console.debug(`reading ${args.path}`);
+        let contents = await fs.readFile(args.path, "utf8");
+
+        // 'await import(' 패턴을 찾아 'require('로 변환
+        contents = contents.replace(
+          /\bawait import\(([^)]+)\)/g,
+          (_, modulePath) => {
+            return `require(${modulePath})`;
+          }
+        );
+
+        return {
+          contents,
+          loader: "ts", // TypeScript를 지원하도록 'ts' 로더 설정
+        };
+      });
+    }
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.3.1",
+  "version": "0.4.2",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -12,11 +12,22 @@
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./kysely": {
+      "import": "./dist/database/drivers/kysely/base-model.mjs",
+      "require": "./dist/database/drivers/kysely/base-model.js",
+      "types": "./dist/database/drivers/kysely/base-model.d.mts"
+    },
+    "./knex": {
+      "import": "./dist/database/drivers/knex/base-model.mjs",
+      "require": "./dist/database/drivers/knex/base-model.js",
+      "types": "./dist/database/drivers/knex/base-model.d.mts"
     }
   },
   "scripts": {
-    "dev": "yarn tsc -w -p ./tsconfig.json",
+    "dev": "tsup --config ./tsup.config.js --watch",
     "build": "tsup --config ./tsup.config.js"
   },
   "license": "MIT",
@@ -39,6 +50,7 @@
     "glob": "^8.0.3",
     "inflection": "^1.13.2",
     "knex": "^3.1.0",
+    "kysely": "^0.27.4",
     "lodash": "^4.17.21",
     "luxon": "^3.0.3",
     "mysql2": "^3.6.1",
@@ -68,7 +80,16 @@
   "peerDependencies": {
     "fastify": "^4.23.2",
     "knex": "^3.1.0",
+    "kysely": "^0.27.4",
     "mysql2": "^3.6.1"
   },
+  "peerDependenciesMeta": {
+    "knex": {
+      "optional": true
+    },
+    "kysely": {
+      "optional": true
+    }
+  },
   "packageManager": "yarn@3.6.3"
 }

package/src/api/caster.ts

@@ -71,6 +71,12 @@ export function caster(zodType: z.ZodType<any>, raw: any): any {
   } else if (zodType instanceof z.ZodNullable) {
     // nullable
     return caster(zodType._def.innerType, raw);
+  } else if (
+    zodType instanceof z.ZodDate &&
+    new Date(raw).toString() !== "Invalid Date"
+  ) {
+    // date
+    return new Date(raw);
   } else {
     // 나머지는 처리 안함
     return raw;

package/src/api/code-converters.ts

@@ -52,7 +52,9 @@ export function getZodObjectFromApi(
     api.parameters.filter(
       (param) =>
         !ApiParamType.isContext(param.type) &&
-        !ApiParamType.isRefKnex(param.type)
+        !ApiParamType.isRefKnex(param.type) &&
+        !ApiParamType.isRefKysely(param.type) &&
+        !(param.optional === true && param.name.startsWith("_")) // _로 시작하는 파라미터는 제외
     ),
     references
   );

package/src/api/sonamu.ts

@@ -2,6 +2,8 @@ import chalk from "chalk";
 import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
 import { IncomingMessage, Server, ServerResponse } from "http";
 import { ZodError } from "zod";
+import path from "path";
+import fs from "fs-extra";
 import { getZodObjectFromApi } from "./code-converters";
 import { Context } from "./context";
 import { BadRequestException } from "../exceptions/so-exceptions";
@@ -10,15 +12,14 @@ import { fastifyCaster } from "./caster";
 import { ApiParam, ApiParamType } from "../types/types";
 import { Syncer } from "../syncer/syncer";
 import { isLocal, isTest } from "../utils/controller";
-import { DB, SonamuDBConfig } from "../database/db";
-import { BaseModel } from "../database/base-model";
 import { findApiRootPath } from "../utils/utils";
-import path from "path";
-import fs from "fs-extra";
 import { ApiDecoratorOptions } from "./decorators";
-import { attachOnDuplicateUpdate } from "../database/knex-plugins/knex-on-duplicate-update";
+import { humanizeZodError } from "../utils/zod-error";
+import { DatabaseDriver, SonamuDBConfig } from "../database/types";
+import { DB } from "../database/db";
 
 export type SonamuConfig = {
+  projectName?: string;
   api: {
     dir: string;
   };
@@ -91,13 +92,24 @@ class SonamuClass {
   set dbConfig(dbConfig: SonamuDBConfig) {
     this._dbConfig = dbConfig;
   }
-  get dbConfig(): SonamuDBConfig {
+  get dbConfig() {
     if (this._dbConfig === null) {
       throw new Error("Sonamu has not been initialized");
     }
     return this._dbConfig!;
   }
 
+  private _dbClient: DatabaseDriver | null = null;
+  set dbClient(_dbClient: DatabaseDriver) {
+    this._dbClient = _dbClient;
+  }
+  get dbClient() {
+    if (this._dbClient === null) {
+      throw new Error("Sonamu has not been initialized");
+    }
+    return this._dbClient!;
+  }
+
   private _syncer: Syncer | null = null;
   set syncer(syncer: Syncer) {
     this._syncer = syncer;
@@ -154,9 +166,12 @@ class SonamuClass {
     }
 
     // DB 로드
-    this.dbConfig = await DB.readKnexfile();
+    const baseConfig = await DB.getBaseConfig(this.apiRootPath);
+    this.dbClient = baseConfig.client;
+    DB.init(baseConfig as any);
+    this.dbConfig = DB.fullConfig;
     !doSilent && console.log(chalk.green("DB Config Loaded!"));
-    attachOnDuplicateUpdate();
+    // attachOnDuplicateUpdate();
 
     // Entity 로드
     await EntityManager.autoload(doSilent);
@@ -237,11 +252,10 @@ class SonamuClass {
             reqBody = fastifyCaster(ReqType).parse(request[which] ?? {});
           } catch (e) {
             if (e instanceof ZodError) {
-              // TODO: BadRequest 에러 핸들링 (ZodError issues를 humanize하여 출력하는 로직 필요)
-              throw new BadRequestException(
-                `${(e as ZodError).issues[0].message}`,
-                e.errors
-              );
+              const messages = humanizeZodError(e)
+                .map((issue) => issue.message)
+                .join(" ");
+              throw new BadRequestException(messages);
             } else {
               throw e;
             }
@@ -253,15 +267,20 @@ class SonamuClass {
           // 캐시
           const { cacheKey, cacheTtl, cachedData } = await (async () => {
             if (config.cache) {
-              const cacheKeyRes = config.cache.resolveKey(api.path, reqBody);
-              if (cacheKeyRes.cache === false) {
-                return { cacheKey: null, cachedData: null };
-              }
+              try {
+                const cacheKeyRes = config.cache.resolveKey(api.path, reqBody);
+                if (cacheKeyRes.cache === false) {
+                  return { cacheKey: null, cachedData: null };
+                }
 
-              const cacheKey = cacheKeyRes.key;
-              const cacheTtl = cacheKeyRes.ttl;
-              const cachedData = await config.cache.get(cacheKey);
-              return { cacheKey, cacheTtl, cachedData };
+                const cacheKey = cacheKeyRes.key;
+                const cacheTtl = cacheKeyRes.ttl;
+                const cachedData = await config.cache.get(cacheKey);
+                return { cacheKey, cacheTtl, cachedData };
+              } catch (e) {
+                console.error(e);
+              }
+              return { cacheKey: null, cachedData: null };
             }
             return { cacheKey: null, cachedData: null };
           })();
@@ -301,7 +320,7 @@ class SonamuClass {
   }
 
   async destroy(): Promise<void> {
-    await BaseModel.destroy();
+    await DB.destroy();
   }
 }
 export const Sonamu = new SonamuClass();

package/src/bin/cli.ts

@@ -6,19 +6,27 @@ import dotenv from "dotenv";
 dotenv.config();
 
 import path from "path";
-import { BaseModel } from "../database/base-model";
-import { EntityManager } from "../entity/entity-manager";
-import { Migrator } from "../entity/migrator";
-import { FixtureManager } from "../testing/fixture-manager";
 import { tsicli } from "tsicli";
 import { execSync } from "child_process";
 import fs from "fs-extra";
-import { Sonamu } from "../api";
-import knex, { Knex } from "knex";
 import inflection from "inflection";
 import prettier from "prettier";
-import { SMDManager } from "../smd/smd-manager";
 import process from "process";
+import _ from "lodash";
+import { Sonamu } from "../api";
+import { EntityManager } from "../entity/entity-manager";
+import { Migrator } from "../entity/migrator";
+import { FixtureManager } from "../testing/fixture-manager";
+import { SMDManager } from "../smd/smd-manager";
+import { DB } from "../database/db";
+import {
+  KnexConfig,
+  KyselyConfig,
+  SonamuKnexDBConfig,
+  SonamuKyselyDBConfig,
+} from "../database/types";
+import { KnexClient } from "../database/drivers/knex/client";
+import { KyselyClient } from "../database/drivers/kysely/client";
 
 let migrator: Migrator;
 
@@ -48,6 +56,7 @@ async function bootstrap() {
       ["migrate", "rollback"],
       ["migrate", "reset"],
       ["migrate", "clear"],
+      ["migrate", "status"],
       ["stub", "practice", "#name"],
       ["stub", "entity", "#name"],
       ["scaffold", "model", "#entityId"],
@@ -63,6 +72,7 @@ async function bootstrap() {
       migrate_rollback,
       migrate_clear,
       migrate_reset,
+      migrate_status,
       fixture_init,
       fixture_import,
       fixture_sync,
@@ -82,7 +92,6 @@ bootstrap().finally(async () => {
     await migrator.destroy();
   }
   await FixtureManager.destory();
-  await BaseModel.destroy();
 
   /* Global End */
   console.log(chalk.bgBlue(`END ${new Date()}\n`));
@@ -113,6 +122,14 @@ async function migrate_check() {
   await migrator.check();
 }
 
+async function migrate_status() {
+  await setupMigrator();
+
+  const status = await migrator.getStatus();
+  // status;
+  console.log(status);
+}
+
 async function migrate_rollback() {
   await setupMigrator();
 
@@ -132,79 +149,94 @@ async function migrate_reset() {
 }
 
 async function fixture_init() {
-  const srcConfig = Sonamu.dbConfig.development_master;
+  const _db = DB.getClient("development_master");
+  const srcConn = _db.connectionInfo;
+
   const targets = [
     {
       label: "(REMOTE) Fixture DB",
-      config: Sonamu.dbConfig.fixture_remote,
+      connKey: "fixture_remote",
     },
     {
       label: "(LOCAL) Fixture DB",
-      config: Sonamu.dbConfig.fixture_local,
-      toSkip: (() => {
-        const remoteConn = Sonamu.dbConfig.fixture_remote
-          .connection as Knex.ConnectionConfig;
-        const localConn = Sonamu.dbConfig.fixture_local
-          .connection as Knex.ConnectionConfig;
-        return (
-          remoteConn.host === localConn.host &&
-          remoteConn.database === localConn.database
-        );
-      })(),
+      connKey: "fixture_local",
     },
     {
       label: "(LOCAL) Testing DB",
-      config: Sonamu.dbConfig.test,
+      connKey: "test",
     },
   ] as {
     label: string;
-    config: Knex.Config;
-    toSkip?: boolean;
+    connKey: keyof SonamuKnexDBConfig | keyof SonamuKyselyDBConfig;
   }[];
 
   // 1. 기준DB 스키마를 덤프
   console.log("DUMP...");
   const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;
-  const srcConn = srcConfig.connection as Knex.ConnectionConfig;
   const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;
   execSync(
-    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
+    `mysqldump -h${srcConn.host} -P${srcConn.port} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
   );
-  execSync(
-    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`
+
+  // 2. 마이그레이션 테이블이 존재하면 덤프
+  const dbClient = DB.baseConfig!.client;
+  const migrationTable = DB.migrationTable;
+  const [migrations] = await _db.raw<{ count: number }>(
+    "SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = ?",
+    [srcConn.database, migrationTable]
   );
+  if (migrations.count > 0) {
+    execSync(
+      `mysqldump -h${srcConn.host} -P${srcConn.port} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} ${migrationTable} ${migrationTable}_lock > ${migrationsDump}`
+    );
+  }
 
   // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기
-  for await (const { label, config, toSkip } of targets) {
-    const conn = config.connection as Knex.ConnectionConfig;
-
-    if (toSkip === true) {
+  for await (const { label, connKey } of targets) {
+    const config = DB.connectionInfo[connKey];
+
+    if (
+      label === "(LOCAL) Fixture DB" &&
+      targets.find(
+        (t) =>
+          t.label === "(REMOTE) Fixture DB" &&
+          DB.connectionInfo[t.connKey].host === config.host &&
+          DB.connectionInfo[t.connKey].database === config.database
+      )
+    ) {
       console.log(chalk.red(`${label}: Skipped!`));
       continue;
     }
 
-    const db = knex({
-      ...config,
-      connection: {
-        ...((config.connection ?? {}) as Knex.ConnectionConfig),
-        database: undefined,
-      },
-    });
-    const [[row]] = await db.raw(`SHOW DATABASES LIKE "${conn.database}"`);
+    const db = (() => {
+      if (dbClient === "knex") {
+        const config = _.cloneDeep(DB.fullConfig[connKey]) as KnexConfig;
+        config.connection.database = undefined;
+        return new KnexClient(config);
+      } else {
+        const config = _.cloneDeep(DB.fullConfig[connKey]) as KyselyConfig;
+        config.database = undefined;
+        return new KyselyClient(config);
+      }
+    })();
+
+    const [row] = await db.raw(`SHOW DATABASES LIKE "${config.database}"`);
     if (row) {
       console.log(
-        chalk.yellow(`${label}: Database "${conn.database}" Already exists`)
+        chalk.yellow(`${label}: Database "${config.database}" Already exists`)
       );
       await db.destroy();
       continue;
     }
 
     console.log(`SYNC to ${label}...`);
-    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;
-    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \`${conn.database}\`'`);
-    execSync(`${mysqlCmd} -e 'CREATE DATABASE \`${conn.database}\`'`);
-    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);
-    execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);
+    const mysqlCmd = `mysql -h${config.host} -P${srcConn.port} -u${config.user} -p${config.password}`;
+    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \`${config.database}\`'`);
+    execSync(`${mysqlCmd} -e 'CREATE DATABASE \`${config.database}\`'`);
+    execSync(`${mysqlCmd} ${config.database} < ${dumpFilename}`);
+    if (fs.existsSync(migrationsDump)) {
+      execSync(`${mysqlCmd} ${config.database} < ${migrationsDump}`);
+    }
 
     await db.destroy();
   }
@@ -253,6 +285,7 @@ async function stub_practice(name: string) {
   const fileName = `p${currentSeqNo}-${name}.ts`;
   const dstPath = path.join(practiceDir, fileName);
 
+  // FIXME
   const code = [
     `import { BaseModel } from "sonamu";`,
     "",

package/src/database/_batch_update.ts

@@ -4,6 +4,11 @@
 */
 
 import { Knex } from "knex";
+import { DB } from "./db";
+import { KnexClient } from "./drivers/knex/client";
+import { KyselyClient } from "./drivers/kysely/client";
+import { Transaction } from "kysely";
+import { Database } from "./types";
 
 export type RowWithId<Id extends string> = {
   [key in Id]: any;
@@ -11,7 +16,7 @@ export type RowWithId<Id extends string> = {
 
 /**
  * Batch update rows in a table. Technically its a patch since it only updates the specified columns. Any omitted columns will not be affected
- * @param knex
+ * @param db
  * @param tableName
  * @param ids
  * @param rows
@@ -19,12 +24,12 @@ export type RowWithId<Id extends string> = {
  * @param trx
  */
 export async function batchUpdate<Id extends string>(
-  knex: Knex,
+  db: KnexClient | KyselyClient,
   tableName: string,
   ids: Id[],
   rows: RowWithId<Id>[],
   chunkSize = 50,
-  trx: Knex.Transaction | null = null
+  trx: Knex.Transaction | Transaction<Database> | null = null
 ) {
   const chunks: RowWithId<Id>[][] = [];
   for (let i = 0; i < rows.length; i += chunkSize) {
@@ -33,18 +38,18 @@ export async function batchUpdate<Id extends string>(
 
   const executeUpdate = async (
     chunk: RowWithId<Id>[],
-    transaction: Knex.Transaction
+    transaction: KyselyClient | KnexClient
   ) => {
-    const sql = generateBatchUpdateSQL(knex, tableName, chunk, ids);
-    return knex.raw(sql).transacting(transaction);
+    const sql = generateBatchUpdateSQL(db, tableName, chunk, ids);
+    return transaction.raw(sql);
   };
 
   if (trx) {
     for (const chunk of chunks) {
-      await executeUpdate(chunk, trx);
+      await executeUpdate(chunk, DB.toClient(trx));
     }
   } else {
-    await knex.transaction(async (newTrx) => {
+    await db.trx(async (newTrx) => {
       for (const chunk of chunks) {
         await executeUpdate(chunk, newTrx);
       }
@@ -70,7 +75,7 @@ function generateKeySetFromData(data: Record<string, any>[]) {
 }
 
 function generateBatchUpdateSQL<Id extends string>(
-  knex: Knex,
+  db: KnexClient | KyselyClient,
   tableName: string,
   data: Record<string, any>[],
   identifiers: Id[]
@@ -112,10 +117,10 @@ function generateBatchUpdateSQL<Id extends string>(
     data.map((row) => row[col])
   );
 
-  const sql = knex.raw(
+  const sql = db.createRawQuery(
     `UPDATE \`${tableName}\` SET ${cases.join(", ")} WHERE ${whereInClauses}`,
     [...bindings, ...whereInBindings]
   );
 
-  return sql.toQuery();
+  return sql;
 }

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

@@ -0,0 +1,97 @@
+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;
+    });
+  }
+}