sonamu 0.0.8 → 0.0.10

package/src/bin/cli.ts

@@ -7,27 +7,19 @@ 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";
 import { tsicli } from "tsicli";
 import { execSync } from "child_process";
 import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
-import { findAppRootPath } from "../utils/utils";
+import { Sonamu } from "../api";
 
 let migrator: Migrator;
 let fixtureManager: FixtureManager;
 
 async function bootstrap() {
-  // appRootPath 셋업
-  const appRootPath = await findAppRootPath();
-  Syncer.getInstance({
-    appRootPath,
-  });
-  await DB.readKnexfile(appRootPath);
-  await SMDManager.autoload();
+  await Sonamu.init();
 
   await tsicli(process.argv, {
     types: {
@@ -89,8 +81,6 @@ bootstrap().finally(async () => {
 async function setupMigrator() {
   // migrator
   migrator = new Migrator({
-    appRootPath: Syncer.getInstance().config.appRootPath,
-    knexfile: DB.getKnexfile(),
     mode: "dev",
   });
 }
@@ -138,14 +128,7 @@ async function fixture_sync() {
 }
 
 async function stub_practice(name: string) {
-  console.log({ name });
-  return;
-  const practiceDir = path.join(
-    Syncer.getInstance().config.appRootPath,
-    "api",
-    "src",
-    "practices"
-  );
+  const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
   const fileNames = readdirSync(practiceDir);
 
   const maxSeqNo = (() => {
@@ -200,22 +183,19 @@ async function stub_practice(name: string) {
 }
 
 async function stub_smd(name: string) {
-  const syncer = Syncer.getInstance();
-  await syncer.generateTemplate("smd", {
+  await Sonamu.syncer.generateTemplate("smd", {
     smdId: name,
   });
 }
 
 async function scaffold_model(smdId: string) {
-  const syncer = Syncer.getInstance();
-  await syncer.generateTemplate("model", {
+  await Sonamu.syncer.generateTemplate("model", {
     smdId,
   });
 }
 
 async function scaffold_model_test(smdId: string) {
-  const syncer = Syncer.getInstance();
-  await syncer.generateTemplate("model_test", {
+  await Sonamu.syncer.generateTemplate("model_test", {
     smdId,
   });
 }

package/src/database/db.ts

@@ -1,8 +1,8 @@
 export type DBPreset = "w" | "r";
 import knex, { Knex } from "knex";
 import path from "path";
+import { Sonamu } from "../api";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions";
-import { findAppRootPath } from "../utils/utils";
 
 export type SonamuDBConfig = {
   development_master: Knex.Config;
@@ -17,36 +17,24 @@ export type SonamuDBConfig = {
 class DBClass {
   private wdb?: Knex;
   private rdb?: Knex;
-  private knexfile?: SonamuDBConfig;
 
-  async readKnexfile(_appRootPath?: string): Promise<SonamuDBConfig> {
-    if (this.knexfile) {
-      return this.knexfile;
-    }
-
-    const appRootPath = _appRootPath ?? (await findAppRootPath());
-    const configPath: string = path.join(appRootPath, "/api/dist/configs/db");
+  async readKnexfile(): Promise<SonamuDBConfig> {
+    const dbConfigPath: string = path.join(
+      Sonamu.apiRootPath,
+      "/dist/configs/db"
+    );
     try {
-      const knexfileModule = await import(configPath);
-      this.knexfile = knexfileModule.default as SonamuDBConfig;
-      return this.knexfile;
+      const knexfileModule = await import(dbConfigPath);
+      return knexfileModule.default as SonamuDBConfig;
     } catch {}
 
     throw new ServiceUnavailableException(
-      `DB설정 파일을 찾을 수 없습니다. ${configPath}`
+      `DB설정 파일을 찾을 수 없습니다. ${dbConfigPath}`
     );
   }
 
-  getKnexfile(): SonamuDBConfig {
-    if (this.knexfile) {
-      return this.knexfile;
-    }
-
-    throw new ServiceUnavailableException("DB설정이 로드되지 않았습니다.");
-  }
-
   getDB(which: DBPreset): Knex {
-    const knexfile = this.getKnexfile();
+    const dbConfig = Sonamu.dbConfig;
 
     const instanceName = which === "w" ? "wdb" : "rdb";
 
@@ -57,17 +45,17 @@ class DBClass {
         case "staging":
           config =
             which === "w"
-              ? knexfile["development_master"]
-              : knexfile["development_slave"] ?? knexfile["development_master"];
+              ? dbConfig["development_master"]
+              : dbConfig["development_slave"] ?? dbConfig["development_master"];
           break;
         case "production":
           config =
             which === "w"
-              ? knexfile["production_master"]
-              : knexfile["production_slave"] ?? knexfile["production_master"];
+              ? dbConfig["production_master"]
+              : dbConfig["production_slave"] ?? dbConfig["production_master"];
           break;
         case "test":
-          config = knexfile["test"];
+          config = dbConfig["test"];
           break;
         default:
           throw new Error(

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from "./api/code-converters";
 export * from "./api/context";
 export * from "./api/decorators";
-export * from "./api/init";
+export * from "./api/sonamu";
 export * from "./database/base-model";
 export * from "./database/db";
 export * from "./database/upsert-builder";

package/src/smd/migrator.ts

@@ -49,17 +49,13 @@ import {
 import { propIf } from "../utils/lodash-able";
 import { SMDManager } from "./smd-manager";
 import { SMD } from "./smd";
-import { SonamuDBConfig } from "../database/db";
+import { Sonamu } from "../api";
 
 type MigratorMode = "dev" | "deploy";
 export type MigratorOptions = {
-  appRootPath: string;
-  knexfile: SonamuDBConfig;
   readonly mode: MigratorMode;
 };
 export class Migrator {
-  appRootPath: string;
-  knexfile: SonamuDBConfig;
   readonly mode: MigratorMode;
 
   targets: {
@@ -70,23 +66,21 @@ export class Migrator {
   };
 
   constructor(options: MigratorOptions) {
-    this.appRootPath = options.appRootPath;
-    this.knexfile = options.knexfile;
     this.mode = options.mode;
+    const { dbConfig } = Sonamu;
 
     if (this.mode === "dev") {
-      const devDB = knex(this.knexfile.development_master);
-      const testDB = knex(this.knexfile.test);
-      const fixtureLocalDB = knex(this.knexfile.fixture_local);
+      const devDB = knex(dbConfig.development_master);
+      const testDB = knex(dbConfig.test);
+      const fixtureLocalDB = knex(dbConfig.fixture_local);
 
       const applyDBs = [devDB, testDB, fixtureLocalDB];
       if (
-        (this.knexfile.fixture_local.connection as Knex.MySql2ConnectionConfig)
+        (dbConfig.fixture_local.connection as Knex.MySql2ConnectionConfig)
           .host !==
-        (this.knexfile.fixture_remote.connection as Knex.MySql2ConnectionConfig)
-          .host
+        (dbConfig.fixture_remote.connection as Knex.MySql2ConnectionConfig).host
       ) {
-        const fixtureRemoteDB = knex(this.knexfile.fixture_remote);
+        const fixtureRemoteDB = knex(dbConfig.fixture_remote);
         applyDBs.push(fixtureRemoteDB);
       }
 
@@ -97,8 +91,8 @@ export class Migrator {
         apply: applyDBs,
       };
     } else if (this.mode === "deploy") {
-      const productionDB = knex(this.knexfile.production_master);
-      const testDB = knex(this.knexfile.test);
+      const productionDB = knex(Sonamu.dbConfig.production_master);
+      const testDB = knex(Sonamu.dbConfig.test);
 
       this.targets = {
         pending: productionDB,
@@ -118,7 +112,7 @@ export class Migrator {
         directory: string;
       }[]
     ];
-    const migrationsDir = `${this.appRootPath}/api/src/migrations`;
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     const delList = pendingList.map((df) => {
       return path.join(migrationsDir, df.file).replace(".js", ".ts");
     });
@@ -197,7 +191,7 @@ export class Migrator {
     }
 
     // 실제 코드 생성
-    const migrationsDir = `${this.appRootPath}/api/src/migrations`;
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     codes
       .filter((code) => code.formatted)
       .map((code, index) => {
@@ -226,8 +220,7 @@ export class Migrator {
     const files = (["src", "dist"] as const).reduce(
       (r, which) => {
         const migrationPath = path.join(
-          this.appRootPath,
-          "api",
+          Sonamu.apiRootPath,
           which,
           "migrations"
         );
@@ -281,13 +274,7 @@ export class Migrator {
       }
 
       const filesToRm = diffOnDist.map((filename) => {
-        return path.join(
-          this.appRootPath,
-          "api",
-          "dist",
-          "migrations",
-          filename
-        );
+        return path.join(Sonamu.apiRootPath, "dist", "migrations", filename);
       });
       filesToRm.map((filePath) => {
         unlinkSync(filePath);
@@ -298,8 +285,8 @@ export class Migrator {
 
   async runShadowTest(): Promise<boolean> {
     // ShadowDB 생성 후 테스트 진행
-    const tdb = knex(this.knexfile.test);
-    const tdbConn = this.knexfile.test.connection as Knex.ConnectionConfig;
+    const tdb = knex(Sonamu.dbConfig.test);
+    const tdbConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;
     const shadowDatabase = tdbConn.database + "__migration_shadow";
     const tmpSqlPath = `/tmp/${shadowDatabase}.sql`;
 
@@ -330,7 +317,7 @@ export class Migrator {
 
     // shadow db 테스트 진행
     const sdb = knex({
-      ...this.knexfile.test,
+      ...Sonamu.dbConfig.test,
       connection: {
         ...tdbConn,
         database: shadowDatabase,
@@ -378,7 +365,7 @@ export class Migrator {
     console.log({ rollbackAllResult });
     console.timeEnd(chalk.red("rollback-all:"));
 
-    const migrationsDir = `${this.appRootPath}/api/src/migrations`;
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     console.time(chalk.red("delete migration files"));
     execSync(`rm -f ${migrationsDir}/*`);
     execSync(`rm -f ${migrationsDir.replace("/src/", "/dist/")}/*`);

package/src/smd/smd-manager.ts

@@ -5,7 +5,7 @@ import _ from "lodash";
 import path from "path";
 import { SMD } from "./smd";
 import { SMDInput } from "../types/types";
-import { findAppRootPath } from "../utils/utils";
+import { Sonamu } from "../api/sonamu";
 
 export type SMDNamesRecord = Record<
   | "fs"
@@ -33,10 +33,9 @@ class SMDManagerClass {
     if (this.isAutoloaded) {
       return;
     }
-    const appRootPath = await findAppRootPath();
     const pathPattern = path.join(
-      appRootPath,
-      "/api/dist/application/**/*.smd.js"
+      Sonamu.apiRootPath,
+      "/dist/application/**/*.smd.js"
     );
     !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
 

package/src/smd/smd.ts

@@ -21,7 +21,7 @@ import path from "path";
 import { existsSync } from "fs";
 import { z } from "zod";
 import { EnumsLabelKo } from "../types/types";
-import { Syncer } from "../syncer";
+import { Sonamu } from "../api/sonamu";
 
 export class SMD {
   id: string;
@@ -437,7 +437,6 @@ export class SMD {
 
   registerModulePaths() {
     const basePath = `${this.names.fs}`;
-    const appRootPath = Syncer.getInstance().config.appRootPath;
 
     // base-scheme
     SMDManager.setModulePath(
@@ -465,9 +464,9 @@ export class SMD {
 
     // types
     const typesModulePath = `${basePath}/${this.names.fs}.types`;
-    const typesFileDistPath = path.resolve(
-      appRootPath,
-      `api/dist/application/${typesModulePath}.js`
+    const typesFileDistPath = path.join(
+      Sonamu.apiRootPath,
+      `dist/application/${typesModulePath}.js`
     );
 
     if (existsSync(typesFileDistPath)) {
@@ -485,9 +484,9 @@ export class SMD {
 
     // enums
     const enumsModulePath = `${basePath}/${this.names.fs}.enums`;
-    const enumsFileDistPath = path.resolve(
-      appRootPath,
-      `api/dist/application/${enumsModulePath}.js`
+    const enumsFileDistPath = path.join(
+      Sonamu.apiRootPath,
+      `/dist/application/${enumsModulePath}.js`
     );
     if (existsSync(enumsFileDistPath)) {
       const importPath = path.relative(__dirname, enumsFileDistPath);

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,10 +217,8 @@ 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);
     }
@@ -328,18 +310,26 @@ export class Syncer {
   }
 
   async actionSyncFilesToTargets(tsPaths: string[]): Promise<string[]> {
+    const { targets } = Sonamu.config.sync;
+    const { dir: apiDir } = Sonamu.config.api;
+    const { appRootPath } = Sonamu;
+
     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)) {
                 mkdirSync(dir, { recursive: true });
               }
+              console.log(
+                "COPIED ",
+                chalk.blue(dst.replace(appRootPath + "/", ""))
+              );
               await this.copyFileWithReplaceCoreToShared(src, dst);
               return dst;
             })
@@ -352,13 +342,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 +375,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 +660,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 +675,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 +687,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 +770,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 +876,9 @@ 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 { appRootPath } = Sonamu;
+    const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
 
     const dstFilePaths = uniq(
       targets.map((target) => filePath.replace("/:target/", `/${target}/`))
@@ -903,7 +890,10 @@ export class Syncer {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync(dstFilePath, pathAndCode.code);
-        console.log("GENERATED ", chalk.blue(dstFilePath));
+        console.log(
+          "GENERATED ",
+          chalk.blue(dstFilePath.replace(appRootPath + "/", ""))
+        );
         return dstFilePath;
       })
     );
@@ -949,8 +939,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 +981,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 +1006,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);