@simplysm/sd-cli 7.0.65 → 7.0.66

package/src/ng-tools/{NgModuleGenerator.ts → SdCliNgModuleGenerator.ts}

@@ -1,5 +1,5 @@
 import { SdCliTsRootMetadata } from "./typescript/SdCliTsRootMetadata";
-import { SdCliBbRootMetadata } from "./babel/SdCliBbRootMetadata";
+import { SdCliBbRootMetadata, TSdCliBbMetadata } from "./babel/SdCliBbRootMetadata";
 import { SdCliBbClassMetadata, SdCliBbObjectMetadata } from "./babel/TSdCliBbTypeMetadata";
 import {
   SdCliBbNgComponentMetadata,
@@ -7,7 +7,7 @@ import {
   SdCliBbNgModuleMetadata,
   SdCliBbNgPipeMetadata
 } from "./babel/TSdCliBbNgMetadata";
-import { NeverEntryError } from "@simplysm/sd-core-common";
+import { NeverEntryError, StringUtil } from "@simplysm/sd-core-common";
 import { TSdCliMetaRef } from "./commons";
 import { SdCliTsNgInjectableMetadata } from "./typescript/SdCliTsFileMetadata";
 import path from "path";
@@ -16,29 +16,43 @@ import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
 import os from "os";
 
 // TODO: 에러 메시지 처리
-export class NgModuleGenerator {
+// TODO: forRoot에 있는 Provider 처리??
+export class SdCliNgModuleGenerator {
   private readonly _bbMeta: SdCliBbRootMetadata;
   private readonly _tsMeta: SdCliTsRootMetadata;
 
-  private readonly _srcPath = path.resolve(process.cwd(), "packages", "sd-angular", "src");
-  private readonly _modulesPath = path.resolve(process.cwd(), "packages", "sd-angular", "src", "_modules");
+  private readonly _srcPath: string;
+  private readonly _modulesPath: string;
 
   private readonly _fileWriterCache = new Map<string, string>();
 
-  public constructor(packagePath: string, private readonly _srcDirRelPaths: string[]) {
+  public constructor(packagePath: string,
+                     private readonly _srcDirRelPaths: string[],
+                     private readonly _routeOpts: {
+                       glob: string;
+                       fileEndsWith: string;
+                       rootClassName: string;
+                     } | undefined) {
+    this._srcPath = path.resolve(packagePath, "src");
+    this._modulesPath = path.resolve(packagePath, "src", "_modules");
+
     this._bbMeta = new SdCliBbRootMetadata(packagePath);
     this._tsMeta = new SdCliTsRootMetadata(packagePath);
-  }
 
-  public async clearModulesAsync(): Promise<void> {
-    await FsUtil.removeAsync(this._modulesPath);
+    const glob = FsUtil.glob(path.resolve(this._modulesPath, "**", "*.ts"));
+    for (const currFilePath of glob) {
+      const content = FsUtil.readFile(currFilePath);
+      this._fileWriterCache.set(currFilePath, content);
+    }
   }
 
   public removeCaches(changedFilePaths: string[]): void {
     this._bbMeta.removeCaches(changedFilePaths);
     this._tsMeta.removeCaches(changedFilePaths);
     for (const changedFilePath of changedFilePaths) {
-      this._fileWriterCache.delete(changedFilePath);
+      if (this._fileWriterCache.has(changedFilePath) && !FsUtil.exists(changedFilePath)) {
+        this._fileWriterCache.delete(changedFilePath);
+      }
     }
   }
 
@@ -46,8 +60,20 @@ export class NgModuleGenerator {
     const bbNgModules = this._getBbNgModuleDefs();
     const tsPreset = this._getTsGenNgModulePreset();
 
+    const genNgRoutingModules = await this._getGenNgRoutingModuleDefsAsync();
     const genNgModules = this._getGenNgModuleDefs(bbNgModules, tsPreset.modules, tsPreset.sources);
-    await this._genFileAsync(genNgModules);
+
+    const files = [
+      ...this._getGenNgRoutingModuleFiles(genNgRoutingModules),
+      ...this._getGenNgModuleFiles(genNgModules)
+    ];
+
+    await this._writeFilesAsync(files);
+  }
+
+  private _findBbMetasFromMeta(srcMeta: TSdCliBbMetadata): TSdCliBbMetadata[] {
+    const metaTmp = typeof srcMeta !== "string" && "__TSdCliMetaRef__" in srcMeta ? this._bbMeta.findMeta(srcMeta) : srcMeta;
+    return metaTmp instanceof Array ? metaTmp : [metaTmp];
   }
 
   private _getBbNgModuleDefs(): IBbNgModuleDef[] {
@@ -57,8 +83,7 @@ export class NgModuleGenerator {
     for (const moduleName of Object.keys(entryRecord)) {
       const fileMeta = entryRecord[moduleName];
       for (const exp of fileMeta.exports) {
-        const metaTmp = typeof exp.target !== "string" && "__TDeclRef__" in exp.target ? this._bbMeta.findMeta(exp.target) : exp.target;
-        const metas = metaTmp instanceof Array ? metaTmp : [metaTmp];
+        const metas = this._findBbMetasFromMeta(exp.target);
         for (const meta of metas) {
           if (meta instanceof SdCliBbClassMetadata) {
             if (meta.ngDecl instanceof SdCliBbNgModuleMetadata) {
@@ -66,7 +91,7 @@ export class NgModuleGenerator {
 
               const resultItem: IBbNgModuleDef = {
                 moduleName,
-                name: exp.exportedName,
+                name: exp.exportedName === "*" ? meta.name : exp.exportedName,
                 providers: [],
                 exports: [],
                 selectors: [],
@@ -74,49 +99,37 @@ export class NgModuleGenerator {
               };
 
               for (const modProv of ngDecl.def.providers) {
-                if (modProv instanceof SdCliBbClassMetadata) {
-                  const ref = this._bbMeta.findExportRef({
-                    filePath: modProv.filePath,
-                    name: modProv.name
-                  });
-                  if (ref) {
-                    resultItem.providers.push(ref);
-                  }
-                }
-                else if (modProv instanceof SdCliBbObjectMetadata) {
-                  // 무시
-                }
-                else {
+                const modProvMetas = this._findBbMetasFromMeta(modProv);
+                if (modProvMetas.length === 0) {
                   throw new NeverEntryError();
                 }
-              }
-
-              for (const modExp of ngDecl.def.exports) {
-                if (modExp instanceof SdCliBbClassMetadata) {
-                  const ref = this._bbMeta.findExportRef({
-                    filePath: modExp.filePath,
-                    name: modExp.name
-                  });
-                  if (ref) {
-                    resultItem.exports.push(ref);
-                  }
 
-                  if (modExp.ngDecl instanceof SdCliBbNgDirectiveMetadata) {
-                    resultItem.selectors.push(modExp.ngDecl.selector);
-                  }
-                  else if (modExp.ngDecl instanceof SdCliBbNgComponentMetadata) {
-                    resultItem.selectors.push(modExp.ngDecl.selector);
+                for (const modProvMeta of modProvMetas) {
+                  if (modProvMeta instanceof SdCliBbClassMetadata) {
+                    const ref = this._bbMeta.findExportRef({
+                      filePath: modProvMeta.filePath,
+                      name: modProvMeta.name
+                    });
+                    if (ref) {
+                      resultItem.providers.push(ref);
+                    }
                   }
-                  else if (modExp.ngDecl instanceof SdCliBbNgPipeMetadata) {
-                    resultItem.pipeNames.push(modExp.ngDecl.pipeName);
+                  else if (modProvMeta instanceof SdCliBbObjectMetadata) {
+                    // 무시
                   }
-                }
-                else if (typeof modExp !== "string" && "__TDeclRef__" in modExp) {
-                  const modExpMeta = this._bbMeta.findMeta(modExp);
-                  if (modExpMeta instanceof Array) {
+                  else {
                     throw new NeverEntryError();
                   }
+                }
+              }
+
+              for (const modExp of ngDecl.def.exports) {
+                const modExpMetas = this._findBbMetasFromMeta(modExp);
+                if (modExpMetas.length === 0) {
+                  throw new NeverEntryError();
+                }
 
+                for (const modExpMeta of modExpMetas) {
                   if (modExpMeta instanceof SdCliBbClassMetadata) {
                     const ref = this._bbMeta.findExportRef({
                       filePath: modExpMeta.filePath,
@@ -136,9 +149,9 @@ export class NgModuleGenerator {
                       resultItem.pipeNames.push(modExpMeta.ngDecl.pipeName);
                     }
                   }
-                }
-                else {
-                  throw new NeverEntryError();
+                  else {
+                    throw new NeverEntryError();
+                  }
                 }
               }
 
@@ -211,17 +224,17 @@ export class NgModuleGenerator {
         if ("moduleName" in imp) {
           for (const mod of bbModules) {
             if (mod.exports.some((item) => item.moduleName === imp.moduleName && item.name === imp.name)) {
-              imports.push({ moduleName: mod.moduleName, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ moduleName: mod.moduleName, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
             if (mod.providers.some((item) => item.moduleName === imp.moduleName && item.name === imp.name)) {
-              imports.push({ moduleName: mod.moduleName, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ moduleName: mod.moduleName, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
           }
         }
         else {
           for (const mod of presetModules) {
             if (mod.source && mod.source.filePath === imp.filePath && mod.source.name === imp.name) {
-              imports.push({ filePath: mod.filePath, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ filePath: mod.filePath, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
           }
         }
@@ -239,13 +252,13 @@ export class NgModuleGenerator {
                 selector.replace(/\[/g, "[\\(").replace(/]/g, "\\)]")
               ].join(", ")) != null
             ) {
-              imports.push({ moduleName: mod.moduleName, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ moduleName: mod.moduleName, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
           }
 
           for (const pipeName of mod.pipeNames) {
             if (new RegExp("| *" + pipeName + "[^\\w]").test(el.template)) {
-              imports.push({ moduleName: mod.moduleName, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ moduleName: mod.moduleName, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
           }
         }
@@ -259,13 +272,13 @@ export class NgModuleGenerator {
                 mod.selector.replace(/\[/g, "[\\(").replace(/]/g, "\\)]")
               ].join(", ")) != null
             ) {
-              imports.push({ filePath: mod.filePath, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ filePath: mod.filePath, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
           }
 
           if (mod.pipeName !== undefined) {
             if (new RegExp("| *" + mod.pipeName + "[^\\w]").test(el.template)) {
-              imports.push({ filePath: mod.filePath, name: mod.name, __TDeclRef__: "__TDeclRef__" });
+              imports.push({ filePath: mod.filePath, name: mod.name, __TSdCliMetaRef__: "__TSdCliMetaRef__" });
             }
           }
         }
@@ -283,7 +296,126 @@ export class NgModuleGenerator {
     return result;
   }
 
-  private async _genFileAsync(mods: ITsGenNgModuleDef[]): Promise<void> {
+  private async _getGenNgRoutingModuleDefsAsync(): Promise<TTsGenNgRoutingModuleDef[]> {
+    if (this._routeOpts === undefined) return [];
+
+    const result: TTsGenNgRoutingModuleDef[] = [];
+
+    const filePaths = await FsUtil.globAsync(path.resolve(this._srcPath, this._routeOpts.glob));
+    for (const filePath of filePaths) {
+      const sourceClassName = path.basename(filePath, path.extname(filePath));
+      if (sourceClassName === this._routeOpts.rootClassName) {
+        const childDirName = StringUtil.toKebabCase(sourceClassName.slice(0, -this._routeOpts.fileEndsWith.length));
+        const childDirPath = path.resolve(path.dirname(filePath), childDirName);
+
+        result.push({
+          filePath: path.resolve(this._srcPath, "_routes"),
+          children: await this._getGenNgRoutingModuleDefChildrenAsync(childDirPath)
+        });
+      }
+      else {
+        const routingModuleClassName = sourceClassName + "RoutingModule";
+        const routingModuleFilePath = path.resolve(this._modulesPath, path.relative(this._srcPath, path.dirname(filePath)), routingModuleClassName);
+        const childDirName = StringUtil.toKebabCase(sourceClassName.slice(0, -this._routeOpts.fileEndsWith.length));
+        const childDirPath = path.resolve(path.dirname(filePath), childDirName);
+
+        result.push({
+          filePath: routingModuleFilePath,
+          name: routingModuleClassName,
+          component: { filePath: filePath.replace(/\.ts$/, ""), name: sourceClassName },
+          children: FsUtil.exists(childDirPath) ? await this._getGenNgRoutingModuleDefChildrenAsync(childDirPath) : undefined
+        });
+      }
+    }
+
+    return result;
+  }
+
+  private async _getGenNgRoutingModuleDefChildrenAsync(rootPath: string): Promise<TTsGenNgRoutingModuleDefChild[]> {
+    const result: TTsGenNgRoutingModuleDefChild[] = [];
+
+    const childNames = await FsUtil.readdirAsync(rootPath);
+    for (const childName of childNames) {
+      if (!FsUtil.stat(path.resolve(rootPath, childName)).isDirectory()) { // 파일
+        const sourceFilePath = path.resolve(rootPath, childName);
+        const sourceClassName = path.basename(sourceFilePath, path.extname(childName));
+        const moduleClassName = sourceClassName + "Module";
+        const moduleFilePath = path.resolve(this._modulesPath, path.relative(this._srcPath, path.dirname(sourceFilePath)), moduleClassName);
+
+        result.push({
+          path: StringUtil.toKebabCase(childName.substring(0, childName.length - 7)),
+          target: { filePath: moduleFilePath, name: moduleClassName }
+        });
+      }
+      else if (!FsUtil.exists(path.resolve(rootPath, StringUtil.toPascalCase(childName) + this._routeOpts!.fileEndsWith + ".ts"))) { // 파일없는 디렉토리
+        result.push({
+          path: childName,
+          children: await this._getGenNgRoutingModuleDefChildrenAsync(path.resolve(rootPath, childName))
+        });
+      }
+    }
+
+    return result;
+  }
+
+  private _getGenNgRoutingModuleFiles(defs: TTsGenNgRoutingModuleDef[]): { filePath: string; content: string }[] {
+    const result: { filePath: string; content: string }[] = [];
+
+    for (const def of defs) {
+      const fn = (children: TTsGenNgRoutingModuleDefChild[]): string => {
+        let fnResult = "[\n";
+        for (const child of children) {
+          fnResult += "  {\n";
+          fnResult += `    path: "${child.path}",\n`;
+          if ("target" in child) {
+            fnResult += `    loadChildren: async () => await import("${this._getImportModuleName(def.filePath, child.target.filePath)}").then((m) => m.${child.target.name})\n`;
+          }
+          else {
+            fnResult += `    children: ${fn(child.children).replace(/\n/g, "\n  ")}\n`;
+          }
+          fnResult += "  },\n";
+        }
+        fnResult = fnResult.slice(0, -2) + "\n";
+        fnResult += "]";
+
+        return fnResult;
+      };
+
+      const content = "component" in def ? `
+import { NgModule } from "@angular/core";
+import { RouterModule } from "@angular/router";
+import { SdCanDeactivateGuard } from "@simplysm/sd-angular";
+import { ${def.component.name} } from "${this._getImportModuleName(def.filePath, def.component.filePath)}";
+
+@NgModule({
+  imports: [
+    RouterModule.forChild([
+      {
+        path: "",
+        component: ${def.component.name},
+        canDeactivate: [SdCanDeactivateGuard]${def.children ? `,
+        children: ${fn(def.children).replace(/\n/g, "\n        ")}` : ""}
+      }
+    ])
+  ],
+  exports: [RouterModule]
+})
+export class ${def.name} {
+}`.trim() : `
+import { Routes } from "@angular/router";
+
+export const routes: Routes = ${fn(def.children)};
+`.trim();
+
+      result.push({ filePath: def.filePath + ".ts", content });
+    }
+
+    return result;
+  }
+
+  private _getGenNgModuleFiles(mods: ITsGenNgModuleDef[]): { filePath: string; content: string }[] {
+    const result: { filePath: string; content: string }[] = [];
+
     for (const mod of mods) {
       const importMap = [...mod.imports, ...mod.exports, ...mod.providers]
         .map((item) => ({
@@ -301,11 +433,22 @@ export class NgModuleGenerator {
         importTexts.push(`import { ${targetNames.join(", ")} } from "${moduleName}";`);
       }
 
+      const moduleImportNames = mod.imports.map((item) => item.name);
+      if (
+        this._routeOpts !== undefined
+        && mod.filePath.endsWith(this._routeOpts.fileEndsWith + "Module")
+        && mod.name !== this._routeOpts.rootClassName + "Module"
+      ) {
+        const routingModuleName = mod.name.replace(/Module$/, "RoutingModule");
+        importTexts.push(`import { ${routingModuleName} } from "./${routingModuleName}";`);
+        moduleImportNames.push(routingModuleName);
+      }
+
       const content = `
 ${importTexts.join(os.EOL)}
 
 @NgModule({
-  imports: [${mod.imports.map((item) => item.name).orderBy().join(", ")}],
+  imports: [${moduleImportNames.orderBy().join(", ")}],
   declarations: [${mod.exports.map((item) => item.name).distinct().orderBy().join(", ")}],
   exports: [${mod.exports.map((item) => item.name).distinct().orderBy().join(", ")}],
   providers: [${mod.providers.map((item) => item.name).distinct().orderBy().join(", ")}]
@@ -313,9 +456,25 @@ ${importTexts.join(os.EOL)}
 export class ${mod.name} {
 }`.trim();
 
-      if (this._fileWriterCache.get(mod.filePath) !== content) {
-        await FsUtil.writeFileAsync(mod.filePath + ".ts", content);
-        this._fileWriterCache.set(mod.filePath, content);
+      result.push({ filePath: mod.filePath + ".ts", content });
+    }
+
+    return result;
+  }
+
+  private async _writeFilesAsync(files: { filePath: string; content: string }[]): Promise<void> {
+    for (const file of files) {
+      if (this._fileWriterCache.get(file.filePath) !== file.content) {
+        await FsUtil.writeFileAsync(file.filePath, file.content);
+        this._fileWriterCache.set(file.filePath, file.content);
+      }
+    }
+
+    const glob = await FsUtil.globAsync(path.resolve(this._modulesPath, "**", "*"));
+    for (const currFilePath of glob) {
+      if (!files.some((item) => item.filePath.startsWith(currFilePath))) {
+        await FsUtil.removeAsync(currFilePath);
+        this._fileWriterCache.delete(currFilePath);
       }
     }
   }
@@ -359,3 +518,21 @@ interface ITsGenNgModuleDef {
   exports: { filePath: string; name: string }[];
   providers: { filePath: string; name: string }[];
 }
+
+type TTsGenNgRoutingModuleDef = {
+  filePath: string;
+  name: string;
+  component: { filePath: string; name: string };
+  children?: TTsGenNgRoutingModuleDefChild[];
+} | {
+  filePath: string;
+  children: TTsGenNgRoutingModuleDefChild[];
+};
+
+type TTsGenNgRoutingModuleDefChild = {
+  path: string;
+  target: { filePath: string; name: string };
+} | {
+  path: string;
+  children: TTsGenNgRoutingModuleDefChild[];
+};