sonamu 0.0.1

package/src/api/init.ts

@@ -0,0 +1,128 @@
+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";
+
+export type SonamuInitConfig = {
+  prefix: string;
+  appRootPath: 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 syncer = Syncer.getInstance({
+    appRootPath: config.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(config.appRootPath);
+  const references = await syncer.autoloadTypes(config.appRootPath);
+  const apis = await syncer.autoloadApis(config.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();
+}

package/src/bin/cli.ts

@@ -0,0 +1,115 @@
+/* Global Begin */
+import chalk from "chalk";
+console.log(chalk.bgBlue(`BEGIN ${new Date()}`));
+
+import dotenv from "dotenv";
+dotenv.config();
+
+import path from "path";
+import { BaseModel } from "../database/base-model";
+import { DB } from "../database/db";
+import { SMDManager } from "../smd/smd-manager";
+import { Migrator } from "../smd/migrator";
+import { Syncer } from "../syncer/syncer";
+import { FixtureManager } from "../testing/fixture-manager";
+
+let migrator: Migrator;
+let fixtureManager: FixtureManager;
+
+async function bootstrap() {
+  // appRootPath 셋업
+  const appRootPath = path.resolve(process.cwd(), "..");
+  Syncer.getInstance({
+    appRootPath,
+  });
+  await DB.readKnexfile();
+
+  const [_0, _1, action, ...args] = process.argv;
+  switch (action) {
+    case "migrate":
+      await migrate(args[0] as MigrateSubAction);
+      break;
+    case "fixture":
+      await fixture(args[0] as FixtureSubAction, args.slice(1));
+      break;
+    default:
+      throw new Error(`Unknown action ${action}`);
+  }
+}
+bootstrap().finally(async () => {
+  if (migrator) {
+    await migrator.destroy();
+  }
+  if (fixtureManager) {
+    await fixtureManager.destory();
+  }
+  await BaseModel.destroy();
+
+  /* Global End */
+  console.log(chalk.bgBlue(`END ${new Date()}\n`));
+});
+
+type MigrateSubAction = "run" | "rollback" | "reset" | "clear";
+async function migrate(subAction: MigrateSubAction) {
+  await SMDManager.autoload();
+
+  // migrator
+  migrator = new Migrator({
+    appRootPath: Syncer.getInstance().config.appRootPath,
+    knexfile: DB.getKnexfile(),
+    mode: "dev",
+  });
+
+  switch (subAction) {
+    case "run":
+      await migrator.cleanUpDist();
+      await migrator.run();
+      break;
+    case "rollback":
+      await migrator.rollback();
+      break;
+    case "clear":
+      await migrator.clearPendingList();
+      break;
+    case "reset":
+      await migrator.resetAll();
+      break;
+    default:
+      throw new Error(`Unknown subAction - ${subAction}`);
+  }
+}
+
+type FixtureSubAction = "import" | "sync";
+async function fixture(subAction: FixtureSubAction, extras?: string[]) {
+  await SMDManager.autoload();
+
+  fixtureManager = new FixtureManager();
+
+  switch (subAction) {
+    case "import":
+      if (!extras || Array.isArray(extras) === false || extras.length !== 2) {
+        throw new Error("Import 대상 smdId와 id가 필요합니다.");
+      }
+      const [smdId, idsString] = extras;
+      let ids: number[] = [];
+      if (idsString.includes(",")) {
+        ids = idsString
+          .split(",")
+          .map((idString) => Number(idString))
+          .filter((id) => Number.isNaN(id) === false);
+      } else {
+        ids = [Number(idsString)];
+      }
+      if (smdId === undefined || idsString === undefined || ids.length === 0) {
+        throw new Error("잘못된 입력");
+      }
+      await fixtureManager.importFixture(smdId, ids);
+      await fixtureManager.sync();
+      break;
+    case "sync":
+      await fixtureManager.sync();
+      break;
+    default:
+      throw new Error(`Unknown subAction - ${subAction}`);
+  }
+}

package/src/database/base-model.ts

@@ -0,0 +1,287 @@
+import { DateTime } from "luxon";
+import { Knex } from "knex";
+import { chunk, groupBy, isObject, omit, set, uniq } from "lodash";
+import { attachOnDuplicateUpdate } from "./knex-plugins/knex-on-duplicate-update";
+attachOnDuplicateUpdate();
+import { DBPreset, DB } from "./db";
+import { isCustomJoinClause, SubsetQuery } from "../types/types";
+import { BaseListParams } from "../utils/model";
+import { pluralize, underscore } from "inflection";
+import chalk from "chalk";
+import { UpsertBuilder } from "./upsert-builder";
+
+export class BaseModelClass {
+  public modelName: string = "Unknown";
+
+  /* DB 인스턴스 get, destroy */
+  getDB(which: DBPreset): Knex {
+    return DB.getDB(which);
+  }
+  async destroy() {
+    return DB.destroy();
+  }
+
+  myNow(timestamp?: number): string {
+    const dt: DateTime =
+      timestamp === undefined
+        ? DateTime.local()
+        : DateTime.fromSeconds(timestamp);
+    return dt.toFormat("yyyy-MM-dd HH:mm:ss");
+  }
+
+  async getInsertedIds(
+    wdb: Knex,
+    rows: any[],
+    tableName: string,
+    unqKeyFields: string[],
+    chunkSize: number = 500
+  ) {
+    if (!wdb) {
+      wdb = this.getDB("w");
+    }
+
+    let unqKeys: string[];
+    let whereInField: any, selectField: string;
+    if (unqKeyFields.length > 1) {
+      whereInField = wdb.raw(`CONCAT_WS('_', '${unqKeyFields.join(",")}')`);
+      selectField = `${whereInField} as tmpUid`;
+      unqKeys = rows.map((row) =>
+        unqKeyFields.map((field) => row[field]).join("_")
+      );
+    } else {
+      whereInField = unqKeyFields[0];
+      selectField = unqKeyFields[0];
+      unqKeys = rows.map((row) => row[unqKeyFields[0]]);
+    }
+    const chunks = chunk(unqKeys, chunkSize);
+
+    let resultIds: number[] = [];
+    for (let chunk of chunks) {
+      const dbRows = await wdb(tableName)
+        .select("id", wdb.raw(selectField))
+        .whereIn(whereInField, chunk);
+      resultIds = resultIds.concat(
+        dbRows.map((dbRow: any) => parseInt(dbRow.id))
+      );
+    }
+
+    return resultIds;
+  }
+
+  async useLoaders(db: Knex, rows: any[], loaders: SubsetQuery["loaders"]) {
+    if (loaders.length > 0) {
+      for (let loader of loaders) {
+        let subQ: any;
+        let subRows: any[];
+        let toCol: string;
+
+        const fromIds = rows.map((row) => row[loader.manyJoin.idField]);
+
+        if (loader.manyJoin.through === undefined) {
+          // HasMany
+          subQ = db(loader.manyJoin.toTable)
+            .whereIn(loader.manyJoin.toCol, fromIds)
+            .select([...loader.select, loader.manyJoin.toCol]);
+
+          loader.oneJoins.map((join) => {
+            if (join.join == "inner") {
+              subQ.innerJoin(
+                `${join.table} as ${join.as}`,
+                this.getJoinClause(db, join)
+              );
+            } else if (join.join == "outer") {
+              subQ.leftOuterJoin(
+                `${join.table} as ${join.as}`,
+                this.getJoinClause(db, join)
+              );
+            }
+          });
+          toCol = loader.manyJoin.toCol;
+        } else {
+          // ManyToMany
+          subQ = db(loader.manyJoin.through.table)
+            .join(
+              loader.manyJoin.toTable,
+              `${loader.manyJoin.through.table}.${loader.manyJoin.through.toCol}`,
+              `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`
+            )
+            .whereIn(loader.manyJoin.through.fromCol, fromIds)
+            .select(uniq([...loader.select, loader.manyJoin.through.fromCol]));
+          toCol = loader.manyJoin.through.fromCol;
+        }
+        subRows = await subQ;
+
+        if (loader.loaders) {
+          // 추가 -Many 케이스가 있는 경우 recursion 처리
+          subRows = await this.useLoaders(db, subRows, loader.loaders);
+        }
+
+        // 불러온 row들을 참조ID 기준으로 분류 배치
+        const subRowGroups = groupBy(subRows, toCol);
+        rows = rows.map((row) => {
+          row[loader.as] = (
+            subRowGroups[row[loader.manyJoin.idField]] ?? []
+          ).map((r) => omit(r, toCol));
+          return row;
+        });
+      }
+    }
+    return rows;
+  }
+
+  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]);
+
+        return r;
+      }, {} as any);
+      nullKeys.map((nullKey) => (hydrated[nullKey] = null));
+
+      return hydrated;
+    });
+  }
+
+  async runSubsetQuery<T extends BaseListParams, U extends string>({
+    params,
+    baseTable,
+    subset,
+    subsetQuery,
+    build,
+    debug,
+  }: {
+    subset: U;
+    params: T;
+    subsetQuery: SubsetQuery;
+    build: (buildParams: {
+      qb: Knex.QueryBuilder;
+      db: Knex;
+      select: string[];
+      joins: SubsetQuery["joins"];
+      virtual: string[];
+    }) => Knex.QueryBuilder;
+    baseTable?: string;
+    debug?: boolean | "list" | "count";
+  }): Promise<{
+    rows: any[];
+    total?: number | undefined;
+    subsetQuery: SubsetQuery;
+  }> {
+    const db = this.getDB(subset.startsWith("A") ? "w" : "r");
+    baseTable = baseTable ?? pluralize(underscore(this.modelName));
+
+    const { select, virtual, joins, loaders } = subsetQuery;
+    const qb = build({
+      qb: db.from(baseTable),
+      db,
+      select,
+      joins,
+      virtual,
+    });
+
+    // join
+    joins.map((join) => {
+      if (join.join == "inner") {
+        qb.innerJoin(
+          `${join.table} as ${join.as}`,
+          this.getJoinClause(db, join)
+        );
+      } else if (join.join == "outer") {
+        qb.leftOuterJoin(
+          `${join.table} as ${join.as}`,
+          this.getJoinClause(db, join)
+        );
+      }
+    });
+
+    // count
+    let countQuery;
+    if (params.id === undefined && params.withoutCount !== true) {
+      countQuery = qb.clone().clearOrder().count("*", { as: "total" });
+    }
+
+    // limit, offset
+    if (params.num !== 0) {
+      qb.limit(params.num!);
+      qb.offset(params.num! * (params.page! - 1));
+    }
+
+    // select, rows
+    qb.select(select);
+    const listQuery = qb.clone();
+
+    // debug: listQuery
+    if (debug === true || debug === "list") {
+      console.debug(
+        "DEBUG: list query",
+        chalk.blue(listQuery.toQuery().toString())
+      );
+    }
+
+    // listQuery
+    let rows = await listQuery;
+    rows = await this.useLoaders(db, rows, loaders);
+    rows = this.hydrate(rows);
+
+    // countQuery
+    let total = 0;
+    if (countQuery) {
+      const countResult = await countQuery;
+      if (countResult && countResult[0] && countResult[0].total) {
+        total = countResult[0].total;
+      }
+
+      // debug: countQuery
+      if (debug === true || debug === "count") {
+        console.debug(
+          "DEBUG: count query",
+          chalk.blue(countQuery.toQuery().toString())
+        );
+      }
+    }
+
+    return { rows, total, subsetQuery };
+  }
+
+  getJoinClause(
+    db: Knex<any, unknown>,
+    join: SubsetQuery["joins"][number]
+  ): Knex.Raw<any> {
+    if (!isCustomJoinClause(join)) {
+      return db.raw(`${join.from} = ${join.to}`);
+    } else {
+      return db.raw(join.custom);
+    }
+  }
+
+  getUpsertBuilder(): UpsertBuilder {
+    return new UpsertBuilder();
+  }
+}
+export const BaseModel = new BaseModelClass();

package/src/database/db.ts

@@ -0,0 +1,95 @@
+export type DBPreset = "w" | "r";
+import knex, { Knex } from "knex";
+import path from "path";
+import { ServiceUnavailableException } from "../exceptions/so-exceptions";
+import { Syncer } from "../syncer";
+
+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;
+  private knexfile?: SonamuDBConfig;
+
+  async readKnexfile() {
+    const configPath: string = path.join(
+      Syncer.getInstance().config.appRootPath,
+      "/api/dist/configs/db"
+    );
+    try {
+      const knexfileModule = await import(configPath);
+      this.knexfile = knexfileModule.default as SonamuDBConfig;
+      return this.knexfile;
+    } catch {}
+
+    throw new ServiceUnavailableException(
+      `DB설정 파일을 찾을 수 없습니다. ${configPath}`
+    );
+  }
+
+  getKnexfile(): SonamuDBConfig {
+    if (this.knexfile) {
+      return this.knexfile;
+    }
+
+    throw new ServiceUnavailableException("DB설정 파일을 찾을 수 없습니다.");
+  }
+
+  getDB(which: DBPreset): Knex {
+    const knexfile = this.getKnexfile();
+
+    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"
+              ? knexfile["development_master"]
+              : knexfile["development_slave"] ?? knexfile["development_master"];
+          break;
+        case "production":
+          config =
+            which === "w"
+              ? knexfile["production_master"]
+              : knexfile["production_slave"] ?? knexfile["production_master"];
+          break;
+        case "test":
+          config = knexfile["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) {
+      if (this.wdb.destroy === undefined) {
+        console.log(this.wdb);
+      }
+      await this.wdb.destroy();
+      this.wdb = undefined;
+    }
+    if (this.rdb !== undefined) {
+      await this.rdb.destroy();
+      this.rdb = undefined;
+    }
+  }
+}
+export const DB = new DBClass();

package/src/database/knex-plugins/knex-on-duplicate-update.ts

@@ -0,0 +1,41 @@
+import knex from "knex";
+
+export function attachOnDuplicateUpdate() {
+  knex.QueryBuilder.extend("onDuplicateUpdate", function (...columns) {
+    if (columns.length === 0) {
+      // 업데이트 할 컬럼이 없으면 onDuplicateUpdate 구문 처리 패스
+      const { sql: originalSQL, bindings: originalBindings } = this.toSQL();
+      return this.client.raw(originalSQL, originalBindings);
+    }
+
+    const { placeholders, bindings } = columns.reduce(
+      (result, column) => {
+        if (typeof column === "string") {
+          result.placeholders.push(`?? = Values(??)`);
+          result.bindings.push(column, column);
+        } else if (column && typeof column === "object") {
+          Object.keys(column).forEach((key) => {
+            result.placeholders.push(`?? = ?`);
+            result.bindings.push(key, column[key]);
+          });
+        } else {
+          throw new Error(
+            "onDuplicateUpdate error: expected column name to be string or object."
+          );
+        }
+
+        return result;
+      },
+      { placeholders: [], bindings: [] }
+    );
+
+    const { sql: originalSQL, bindings: originalBindings } = this.toSQL();
+
+    const newBindings = [...originalBindings, ...bindings];
+
+    return this.client.raw(
+      `${originalSQL} ON DUPLICATE KEY UPDATE ${placeholders.join(", ")}`,
+      newBindings
+    );
+  });
+}