sonamu 0.0.7 → 0.0.9

package/src/syncer/syncer.ts

@@ -82,12 +82,8 @@ import { Template__view_enums_buttonset } from "../templates/view_enums_buttonse
 import { Template__view_search_input } from "../templates/view_search_input.template";
 import { Template__view_list_columns } from "../templates/view_list_columns.template";
 import { Template__generated_http } from "../templates/generated_http.template";
+import { Sonamu } from "../api/sonamu";
 
-type SyncerConfig = {
-  appRootPath: string;
-  checksumsPath: string;
-  targets: string[];
-};
 type FileType = "model" | "types" | "enums" | "smd" | "generated";
 type GlobPattern = {
   [key in FileType]: string;
@@ -112,15 +108,6 @@ export type RenderedTemplate = {
 };
 
 export class Syncer {
-  private static instance: Syncer;
-  public static getInstance(config?: Partial<SyncerConfig>) {
-    if (this.instance && config !== undefined) {
-      throw new Error("Syncer has already configured.");
-    }
-    return this.instance ?? (this.instance = new this(config));
-  }
-
-  config: SyncerConfig;
   apis: {
     typeParameters: ApiParamType.TypeParam[];
     parameters: ApiParam[];
@@ -131,22 +118,19 @@ export class Syncer {
     options: ApiDecoratorOptions;
   }[] = [];
   types: { [typeName: string]: z.ZodObject<any> } = {};
+  models: { [modelName: string]: unknown } = {};
 
-  private constructor(config?: Partial<SyncerConfig>) {
-    const appRootPath =
-      config?.appRootPath ?? path.resolve(__dirname, "../../");
-    this.config = {
-      appRootPath,
-      checksumsPath: `${appRootPath}/api/.tf-checksum`,
-      targets: ["web"],
-      ...config,
-    };
+  get checksumsPath(): string {
+    return path.join(Sonamu.apiRootPath, "/.tf-checksum");
   }
+  public constructor() {}
 
   async sync(): Promise<void> {
+    const { targets } = Sonamu.config.sync;
+
     // 트리거와 무관하게 shared 분배
     await Promise.all(
-      this.config.targets.map(async (target) => {
+      targets.map(async (target) => {
         const srcCodePath = path
           .join(__dirname, `../shared/${target}.shared.ts.txt`)
           .replace("/dist/", "/src/");
@@ -155,7 +139,7 @@ export class Syncer {
         }
 
         const dstCodePath = path.join(
-          this.config.appRootPath,
+          Sonamu.appRootPath,
           target,
           "src/services/sonamu.shared.ts"
         );
@@ -233,16 +217,14 @@ export class Syncer {
     // 트리거: model
     if (diffTypes.includes("model")) {
       const smdIds = this.getSMDIdFromPath(diffGroups["model"]);
-
       console.log("// 액션: 서비스 생성");
       await this.actionGenerateServices(smdIds);
-
       console.log("// 액션: HTTP파일 생성");
       await this.actionGenerateHttps(smdIds);
     }
 
     // 저장
-    await this.saveChecksums(currentChecksums);
+    await this.saveChecksums(await this.getCurrentChecksums());
   }
 
   getSMDIdFromPath(filePaths: string[]): string[] {
@@ -328,13 +310,16 @@ export class Syncer {
   }
 
   async actionSyncFilesToTargets(tsPaths: string[]): Promise<string[]> {
+    const { targets } = Sonamu.config.sync;
+    const { dir: apiDir } = Sonamu.config.api;
+
     return (
       await Promise.all(
-        this.config.targets.map(async (target) =>
+        targets.map(async (target) =>
           Promise.all(
             tsPaths.map(async (src) => {
               const dst = src
-                .replace("/api/", `/${target}/`)
+                .replace(`/${apiDir}/`, `/${target}/`)
                 .replace("/application/", "/services/");
               const dir = dirname(dst);
               if (!existsSync(dir)) {
@@ -352,13 +337,12 @@ export class Syncer {
   async getCurrentChecksums(): Promise<PathAndChecksum[]> {
     const PatternGroup: GlobPattern = {
       /* TS 체크 */
-      types: this.config.appRootPath + "/api/src/application/**/*.types.ts",
-      enums: this.config.appRootPath + "/api/src/application/**/*.enums.ts",
-      generated:
-        this.config.appRootPath + "/api/src/application/**/*.generated.ts",
+      types: Sonamu.apiRootPath + "/src/application/**/*.types.ts",
+      enums: Sonamu.apiRootPath + "/src/application/**/*.enums.ts",
+      generated: Sonamu.apiRootPath + "/src/application/**/*.generated.ts",
       /* compiled-JS 체크 */
-      model: this.config.appRootPath + "/api/dist/application/**/*.model.js",
-      smd: this.config.appRootPath + "/api/dist/application/**/*.smd.js",
+      model: Sonamu.apiRootPath + "/dist/application/**/*.model.js",
+      smd: Sonamu.apiRootPath + "/dist/application/**/*.smd.js",
     };
 
     const filePaths = (
@@ -386,19 +370,19 @@ export class Syncer {
   }
 
   async getPreviousChecksums(): Promise<PathAndChecksum[]> {
-    if (existsSync(this.config.checksumsPath) === false) {
+    if (existsSync(this.checksumsPath) === false) {
       return [];
     }
 
     const previousChecksums = (await readJSON(
-      this.config.checksumsPath
+      this.checksumsPath
     )) as PathAndChecksum[];
     return previousChecksums;
   }
 
   async saveChecksums(checksums: PathAndChecksum[]): Promise<void> {
-    await writeJSON(this.config.checksumsPath, checksums);
-    console.debug("checksum saved", this.config.checksumsPath);
+    await writeJSON(this.checksumsPath, checksums);
+    console.debug("checksum saved", this.checksumsPath);
   }
 
   async getChecksumOfFile(filePath: string): Promise<string> {
@@ -671,10 +655,10 @@ export class Syncer {
     return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
   }
 
-  async autoloadApis(basePath: string) {
+  async autoloadApis() {
     const pathPattern = path.join(
-      basePath,
-      "api/src/application/**/*.model.ts"
+      Sonamu.apiRootPath,
+      "/src/application/**/*.model.ts"
     );
     // console.debug(chalk.yellow(`autoload:APIs @ ${pathPattern}`));
 
@@ -686,12 +670,10 @@ export class Syncer {
     return this.apis;
   }
 
-  async autoloadModels(
-    basePath: string
-  ): Promise<{ [modelName: string]: unknown }> {
+  async autoloadModels(): Promise<{ [modelName: string]: unknown }> {
     const pathPattern = path.join(
-      basePath,
-      "api/dist/application/**/*.model.js"
+      Sonamu.apiRootPath,
+      "dist/application/**/*.model.js"
     );
     // console.debug(chalk.yellow(`autoload:models @ ${pathPattern}`));
 
@@ -700,22 +682,21 @@ export class Syncer {
     const functions = modules
       .map(({ imported }) => Object.entries(imported))
       .flat();
-    return Object.fromEntries(
+    this.models = Object.fromEntries(
       functions.filter(([name]) => name.endsWith("Model"))
     );
+    return this.models;
   }
 
-  async autoloadTypes(
-    basePath: string
-  ): Promise<{ [typeName: string]: z.ZodObject<any> }> {
+  async autoloadTypes(): Promise<{ [typeName: string]: z.ZodObject<any> }> {
     if (Object.keys(this.types).length > 0) {
       return this.types;
     }
 
     const pathPatterns = [
-      path.join(basePath, "api/dist/application/**/*.types.js"),
-      path.join(basePath, "api/dist/application/**/*.enums.js"),
-      path.join(basePath, "api/dist/application/**/*.generated.js"),
+      path.join(Sonamu.apiRootPath, "/dist/application/**/*.types.js"),
+      path.join(Sonamu.apiRootPath, "/dist/application/**/*.enums.js"),
+      path.join(Sonamu.apiRootPath, "/dist/application/**/*.generated.js"),
     ];
     // console.debug(chalk.magenta(`autoload:types @ ${pathPatterns.join("\n")}`));
 
@@ -784,9 +765,9 @@ export class Syncer {
     if (key === "service" || key === "generated_http") {
       // service 필요 정보 (API 리스트)
       const smd = SMDManager.get(options.smdId);
-      const modelTsPath = `${path.resolve(
-        this.config.appRootPath,
-        "api/src/application"
+      const modelTsPath = `${path.join(
+        Sonamu.apiRootPath,
+        "/src/application"
       )}/${smd.names.fs}/${smd.names.fs}.model.ts`;
       extra = [await this.readApisFromFile(modelTsPath)];
     } else if (key === "view_list" || key === "model") {
@@ -890,8 +871,8 @@ export class Syncer {
   }
 
   async writeCodeToPath(pathAndCode: PathAndCode): Promise<string[]> {
-    const { appRootPath, targets } = this.config;
-    const filePath = `${appRootPath}/${pathAndCode.path}`;
+    const { targets } = Sonamu.config.sync;
+    const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
 
     const dstFilePaths = uniq(
       targets.map((target) => filePath.replace("/:target/", `/${target}/`))
@@ -949,8 +930,8 @@ export class Syncer {
     } else {
       filteredPathAndCodes = pathAndCodes.filter((pathAndCode, index) => {
         if (index === 0) {
-          const { appRootPath, targets } = this.config;
-          const filePath = `${appRootPath}/${pathAndCode.path}`;
+          const { targets } = Sonamu.config.sync;
+          const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
           const dstFilePaths = targets.map((target) =>
             filePath.replace("/:target/", `/${target}/`)
           );
@@ -991,21 +972,22 @@ export class Syncer {
         enumsKeys.map((componentId) => {
           const { target, path: p } = tpl.getTargetAndPath(names, componentId);
           result[`${key}__${componentId}`] = existsSync(
-            path.join(this.config.appRootPath, target, p)
+            path.join(Sonamu.appRootPath, target, p)
           );
         });
         return result;
       }
 
       const { target, path: p } = tpl.getTargetAndPath(names);
+      const { targets } = Sonamu.config.sync;
       if (target.includes(":target")) {
-        this.config.targets.map((t) => {
+        targets.map((t) => {
           result[`${key}__${t}`] = existsSync(
-            path.join(this.config.appRootPath, target.replace(":target", t), p)
+            path.join(Sonamu.appRootPath, target.replace(":target", t), p)
           );
         });
       } else {
-        result[key] = existsSync(path.join(this.config.appRootPath, target, p));
+        result[key] = existsSync(path.join(Sonamu.appRootPath, target, p));
       }
 
       return result;
@@ -1015,8 +997,7 @@ export class Syncer {
   async getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny> {
     const modulePath = SMDManager.getModulePath(zodTypeId);
     const moduleAbsPath = path.join(
-      this.config.appRootPath,
-      "api",
+      Sonamu.apiRootPath,
       "dist",
       "application",
       modulePath + ".js"

package/src/templates/generated_http.template.ts

@@ -7,7 +7,7 @@ import { ExtendedApi } from "../api/decorators";
 import { Template } from "./base-template";
 import prettier from "prettier";
 import { DateTime } from "luxon";
-import { Syncer } from "../syncer/syncer";
+import { Sonamu } from "../api/sonamu";
 
 export class Template__generated_http extends Template {
   constructor() {
@@ -23,7 +23,7 @@ export class Template__generated_http extends Template {
 
   render({ smdId }: TemplateOptions["generated"], apis: ExtendedApi[]) {
     const names = SMDManager.getNamesFromId(smdId);
-    const references = Syncer.getInstance().types;
+    const references = Sonamu.syncer.types;
 
     const lines = apis.map((api) => {
       const reqObject = this.resolveApiParams(api, references);

package/src/templates/init_enums.template.ts

@@ -31,7 +31,7 @@ export class Template__init_enums extends Template {
       ...this.getTargetAndPath(names),
       body: `
 import { z } from "zod";
-import { EnumsLabelKo } from "../../types/shared";
+import { EnumsLabelKo } from "sonamu";
 
 ${Object.entries(record)
   .map(

package/src/templates/init_generated.template.ts

@@ -33,10 +33,17 @@ export const ${smdId}BaseListParams = z.object({
   keyword: z.string(),
   orderBy: ${smdId}OrderBy,
   withoutCount: z.boolean(),
-});
+}).partial();
 export type ${smdId}BaseListParams = z.infer<typeof ${smdId}BaseListParams>;
 
+export type ${smdId}SubsetKey = never;
+export type ${smdId}SubsetMapping = {};
+/* BEGIN- Server-side Only */
+import { SubsetQuery } from "sonamu";
+export const ${names.camel}SubsetQueries: { [key in ${smdId}SubsetKey]: SubsetQuery } = {};
+
 export type ${smdId}FieldExpr = string;
+/* END- Server-side Only */
       `.trim(),
       importKeys: [],
     };

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/templates/smd.template.ts

@@ -21,14 +21,14 @@ export class Template__smd extends Template {
     return {
       ...this.getTargetAndPath(names),
       body: `
-import { p, MDInput } from "sonamu";
+import { p, SMDInput } from "sonamu";
 import { ${smdId}FieldExpr } from "./${names.fs}.generated";
 
 /*
   ${smdId} SMD
 */
 
-export const ${names.camel}MdInput: SMDInput<${smdId}FieldExpr> = {
+export const ${names.camel}SmdInput: SMDInput<${smdId}FieldExpr> = {
   id: "${smdId}",
   title: "${title ?? smdId}",
   props: [

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,16 +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 Sonamu.init();
       });
 
       beforeEach(async () => {
@@ -34,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"]);
@@ -67,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");
   }
@@ -146,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(
@@ -164,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();
 
@@ -222,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");
@@ -235,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})`;
@@ -285,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,13 +28,21 @@ 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");
   }
   let dir = path.dirname(require.main.path);
+  if (dir.includes("/.yarn/")) {
+    dir = dir.split("/.yarn/")[0];
+  }
   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);