sonamu 0.0.8 → 0.0.10

package/src/templates/service.template.ts

@@ -10,6 +10,7 @@ import {
 } from "../api/code-converters";
 import { ExtendedApi } from "../api/decorators";
 import { Template } from "./base-template";
+import { Sonamu } from "../api/sonamu";
 
 export class Template__service extends Template {
   constructor() {
@@ -44,10 +45,10 @@ export class Template__service extends Template {
     };
   }
 
-  getTypeSource(
-    apis: ExtendedApi[],
-    apiPrefix: string = "/api"
-  ): { lines: string[]; importKeys: string[] } {
+  getTypeSource(apis: ExtendedApi[]): {
+    lines: string[];
+    importKeys: string[];
+  } {
     const importKeys: string[] = [];
 
     // 제네릭에서 선언한 타입, importKeys에서 제외 필요
@@ -95,7 +96,7 @@ export class Template__service extends Template {
               client === "swr" ? 0 : 1
             )
               .map((client) => {
-                const apiBaseUrl = `${apiPrefix}${api.path}`;
+                const apiBaseUrl = `${Sonamu.config.route.prefix}${api.path}`;
                 switch (client) {
                   case "axios":
                     return this.renderAxios(

package/src/testing/fixture-manager.ts

@@ -2,8 +2,8 @@ import chalk from "chalk";
 import { execSync } from "child_process";
 import knex, { Knex } from "knex";
 import { uniq } from "lodash";
+import { Sonamu } from "../api";
 import { BaseModel } from "../database/base-model";
-import { DB, SonamuDBConfig } from "../database/db";
 import { SMDManager } from "../smd/smd-manager";
 import {
   isBelongsToOneRelationProp,
@@ -11,17 +11,29 @@ import {
 } from "../types/types";
 
 export class FixtureManager {
-  private config?: {
-    tdb: Knex;
-    fdb: Knex;
-    knexfile: SonamuDBConfig;
-  };
+  private _tdb: Knex | null = null;
+  set tdb(tdb: Knex) {
+    this._tdb = tdb;
+  }
+  get tdb(): Knex {
+    return this._tdb!;
+  }
+
+  private _fdb: Knex | null = null;
+  set fdb(fdb: Knex) {
+    this._fdb = fdb;
+  }
+  get fdb(): Knex {
+    return this._fdb!;
+  }
 
   constructor(public usingTables?: string[]) {
+    this.tdb = knex(Sonamu.dbConfig.test);
+    this.fdb = knex(Sonamu.dbConfig.fixture_local);
+
     if (process.env.NODE_ENV === "test") {
       beforeAll(async () => {
-        await this.init();
-        await SMDManager.autoload(true);
+        await Sonamu.init();
       });
 
       beforeEach(async () => {
@@ -35,32 +47,11 @@ export class FixtureManager {
     }
   }
 
-  async init(): Promise<{
-    tdb: Knex;
-    fdb: Knex;
-    knexfile: SonamuDBConfig;
-  }> {
-    if (this.config) {
-      return this.config;
-    }
-
-    const knexfile = await DB.readKnexfile();
-    this.config = {
-      knexfile,
-      tdb: knex(knexfile.test),
-      fdb: knex(knexfile.fixture_local),
-    };
-    return this.config;
-  }
-
   async cleanAndSeed() {
-    const { tdb, fdb, knexfile } = await this.init();
-    // console.time("FIXTURE-CleanAndSeed");
-
     let tableNames: string[] = [];
 
     if (this.usingTables === undefined) {
-      const [tables] = await tdb.raw(
+      const [tables] = await this.tdb.raw(
         "SHOW TABLE STATUS WHERE Engine IS NOT NULL"
       );
       tableNames = tables.map((tableInfo: any) => tableInfo["Name"]);
@@ -68,31 +59,37 @@ export class FixtureManager {
       tableNames = this.usingTables;
     }
 
-    await tdb.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+    await this.tdb.raw(`SET FOREIGN_KEY_CHECKS = 0`);
     for await (let tableName of tableNames) {
       if (tableName == "migrations") {
         continue;
       }
 
-      const [[fdbChecksumRow]] = await fdb.raw(`CHECKSUM TABLE ${tableName}`);
+      const [[fdbChecksumRow]] = await this.fdb.raw(
+        `CHECKSUM TABLE ${tableName}`
+      );
       const fdbChecksum = fdbChecksumRow["Checksum"];
 
-      const [[tdbChecksumRow]] = await tdb.raw(`CHECKSUM TABLE ${tableName}`);
+      const [[tdbChecksumRow]] = await this.tdb.raw(
+        `CHECKSUM TABLE ${tableName}`
+      );
       const tdbChecksum = tdbChecksumRow["Checksum"];
 
       if (fdbChecksum !== tdbChecksum) {
-        await tdb(tableName).truncate();
+        await this.tdb(tableName).truncate();
         const rawQuery = `INSERT INTO ${
-          (knexfile.test.connection as Knex.ConnectionConfig).database
+          (Sonamu.dbConfig.test.connection as Knex.ConnectionConfig).database
         }.${tableName}
             SELECT * FROM ${
-              (knexfile.fixture_local.connection as Knex.ConnectionConfig)
-                .database
+              (
+                Sonamu.dbConfig.fixture_local
+                  .connection as Knex.ConnectionConfig
+              ).database
             }.${tableName}`;
-        await tdb.raw(rawQuery);
+        await this.tdb.raw(rawQuery);
       }
     }
-    await tdb.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    await this.tdb.raw(`SET FOREIGN_KEY_CHECKS = 1`);
 
     // console.timeEnd("FIXTURE-CleanAndSeed");
   }
@@ -147,10 +144,9 @@ export class FixtureManager {
   }
 
   async sync() {
-    const { fdb, knexfile } = await this.init();
-    const frdb = knex(knexfile.fixture_remote);
+    const frdb = knex(Sonamu.dbConfig.fixture_remote);
 
-    const [tables] = await fdb.raw(
+    const [tables] = await this.fdb.raw(
       "SHOW TABLE STATUS WHERE Engine IS NOT NULL"
     );
     const tableNames: string[] = tables.map(
@@ -165,10 +161,10 @@ export class FixtureManager {
         }
 
         const remoteChecksum = await this.getChecksum(frdb, tableName);
-        const localChecksum = await this.getChecksum(fdb, tableName);
+        const localChecksum = await this.getChecksum(this.fdb, tableName);
 
         if (remoteChecksum !== localChecksum) {
-          await fdb.transaction(async (transaction) => {
+          await this.fdb.transaction(async (transaction) => {
             await transaction.raw(`SET FOREIGN_KEY_CHECKS = 0`);
             await transaction(tableName).truncate();
 
@@ -223,8 +219,6 @@ export class FixtureManager {
     field: string,
     id: number
   ): Promise<string[]> {
-    const { knexfile } = await this.init();
-
     console.log({ smdId, field, id });
     const smd = SMDManager.get(smdId);
     const wdb = BaseModel.getDB("w");
@@ -236,9 +230,9 @@ export class FixtureManager {
     }
 
     // 픽스쳐DB, 실DB
-    const fixtureDatabase = (knexfile.fixture_remote.connection as any)
+    const fixtureDatabase = (Sonamu.dbConfig.fixture_remote.connection as any)
       .database;
-    const realDatabase = (knexfile.production_master.connection as any)
+    const realDatabase = (Sonamu.dbConfig.production_master.connection as any)
       .database;
 
     const selfQuery = `INSERT IGNORE INTO \`${fixtureDatabase}\`.\`${smd.table}\` (SELECT * FROM \`${realDatabase}\`.\`${smd.table}\` WHERE \`id\` = ${id})`;
@@ -286,11 +280,7 @@ export class FixtureManager {
   }
 
   async destory() {
-    if (!this.config) {
-      return;
-    }
-    const { tdb, fdb } = await this.init();
-    await tdb.destroy();
-    await fdb.destroy();
+    await this.tdb.destroy();
+    await this.fdb.destroy();
   }
 }

package/src/utils/utils.ts

@@ -28,6 +28,11 @@ export async function importMultiple(
   );
 }
 export async function findAppRootPath() {
+  const apiRootPath = await findApiRootPath();
+  return apiRootPath.split(path.sep).slice(0, -1).join(path.sep);
+}
+
+export async function findApiRootPath() {
   if (require.main === undefined) {
     throw new Error("Cannot find AppRoot using Sonamu");
   }
@@ -37,7 +42,7 @@ export async function findAppRootPath() {
   }
   do {
     if (existsSync(path.join(dir, "/package.json"))) {
-      return dir.split(path.sep).slice(0, -1).join(path.sep);
+      return dir.split(path.sep).join(path.sep);
     }
     dir = dir.split(path.sep).slice(0, -1).join(path.sep);
   } while (dir.split(path.sep).length > 1);

package/src/api/init.ts

@@ -1,129 +0,0 @@
-import chalk from "chalk";
-import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
-import { IncomingMessage, Server, ServerResponse } from "http";
-import { ZodError } from "zod";
-import { getZodObjectFromApi } from "./code-converters";
-import { Context } from "./context";
-import { BadRequestException } from "../exceptions/so-exceptions";
-import { SMDManager } from "../smd/smd-manager";
-import { fastifyCaster } from "../api/caster";
-import { ApiParamType } from "../types/types";
-import { Syncer } from "../syncer/syncer";
-import { isLocal } from "../utils/controller";
-import { DB } from "../database/db";
-import { BaseModel } from "../database/base-model";
-import { findAppRootPath } from "../utils/utils";
-
-export type SonamuInitConfig = {
-  prefix: string;
-  syncTargets: string[];
-  contextProvider: (
-    defaultContext: Pick<Context, "headers" | "reply">,
-    request: FastifyRequest,
-    reply: FastifyReply
-  ) => Context;
-};
-export async function init(
-  server: FastifyInstance<Server, IncomingMessage, ServerResponse>,
-  config: SonamuInitConfig
-) {
-  // 전체 라우팅 리스트
-  server.get(
-    `${config.prefix}/routes`,
-    async (_request, _reply): Promise<any> => {
-      return apis;
-    }
-  );
-
-  // Healthcheck API
-  server.get(
-    `${config.prefix}/healthcheck`,
-    async (_request, _reply): Promise<string> => {
-      return "ok";
-    }
-  );
-
-  // Syncer
-  const appRootPath = await findAppRootPath();
-  const syncer = Syncer.getInstance({
-    appRootPath: appRootPath,
-    targets: config.syncTargets,
-  });
-
-  // DB 설정파일 확인
-  await DB.readKnexfile();
-  console.log(chalk.green("DB Config Loaded!"));
-
-  // Autoload: SMD / Models / Types / APIs
-  console.time(chalk.cyan("autoload&sync:"));
-  await SMDManager.autoload();
-  const importedModels = await syncer.autoloadModels(appRootPath);
-  const references = await syncer.autoloadTypes(appRootPath);
-  const apis = await syncer.autoloadApis(appRootPath);
-  if (isLocal()) {
-    await syncer.sync();
-  }
-  console.timeEnd(chalk.cyan("autoload&sync:"));
-
-  // API 라우팅 등록
-  apis.map((api) => {
-    // model
-    if (importedModels[api.modelName] === undefined) {
-      throw new Error(`정의되지 않은 모델에 접근 ${api.modelName}`);
-    }
-    const model = importedModels[api.modelName];
-
-    // 파라미터 정보로 zod 스키마 빌드
-    const ReqType = getZodObjectFromApi(api, references);
-
-    // route
-    server.route({
-      method: api.options.httpMethod!,
-      url: config.prefix + api.path,
-      handler: async (request, reply): Promise<unknown> => {
-        const which = api.options.httpMethod === "GET" ? "query" : "body";
-        let reqBody: {
-          [key: string]: unknown;
-        };
-        try {
-          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
-            );
-          } else {
-            throw e;
-          }
-        }
-
-        const result = await (model as any)[api.methodName].apply(
-          model,
-          api.parameters.map((param) => {
-            // Context 인젝션
-            if (ApiParamType.isContext(param.type)) {
-              return config.contextProvider(
-                {
-                  headers: request.headers,
-                  reply,
-                },
-                request,
-                reply
-              );
-            } else {
-              return reqBody[param.name];
-            }
-          })
-        );
-        reply.type(api.options.contentType ?? "application/json");
-        return result;
-      },
-    }); // END server.route
-  });
-}
-
-export async function destroy(): Promise<void> {
-  await BaseModel.destroy();
-}