@simplysm/sd-cli 6.0.28 → 6.0.38

package/src/build-tools/SdCliNgModuleFilesGenerator.ts

@@ -1,5 +1,5 @@
 import { ISdPackageBuildResult } from "../commons";
-import { NeverEntryError, ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
+import { NeverEntryError, ObjectUtil, SdError, StringUtil } from "@simplysm/sd-core-common";
 import * as ts from "typescript";
 import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
 import * as path from "path";
@@ -25,7 +25,9 @@ import {
 } from "./metadata/SdAotMetadataReader";
 import { IIvyNgModuleMetadata, SdIvyMetadataReader, TIvyNgMetadata } from "./metadata/SdIvyMetadataReader";
 import { NgtscProgram } from "@angular/compiler-cli";
+import { SdMetadataError } from "./metadata/SdMetadataError";
 
+// TODO: LazyPage??
 export class SdCliNgModuleFilesGenerator {
   private readonly _fileCache = new Map<string, TFileCache>();
 
@@ -57,61 +59,86 @@ export class SdCliNgModuleFilesGenerator {
 
     let changed = false;
     for (const dirtyFilePath of dirtyFilePaths) {
-      if (PathUtil.isChildPath(dirtyFilePath, this._moduleDistDirPath)) continue;
+      try {
+        if (PathUtil.isChildPath(dirtyFilePath, this._moduleDistDirPath)) continue;
 
-      this._fileCache.delete(dirtyFilePath);
+        this._fileCache.delete(dirtyFilePath);
 
-      // 내 소스코드
-      if (dirtyFilePath.endsWith(".ts") && !dirtyFilePath.endsWith(".d.ts")) {
-        const sourceFile = this._program.getSourceFile(dirtyFilePath);
-        if (!sourceFile) throw new NeverEntryError();
-
-        this._fileCache.set(dirtyFilePath, {
-          type: "my",
-          sourceFile,
-          metadata: new SdMyMetadataReader(sourceFile, this._program).getMetadatas()
-        });
-        changed = true;
-      }
-
-      // AOT 라이브러리
-      else if (dirtyFilePath.endsWith(".d.ts")) {
-        const sourceFile = this._program.getSourceFile(dirtyFilePath);
-        if (!sourceFile) throw new NeverEntryError();
-
-        // from METADATA
-        const metadataFilePath = dirtyFilePath.replace(/\.d\.ts$/, ".metadata.json");
-        const sdMetadataFilePath = dirtyFilePath.replace(/\.d\.ts$/, ".sd-metadata.json");
-
-        if (FsUtil.exists(metadataFilePath)) {
-          const metadataRoot = await FsUtil.readJsonAsync(metadataFilePath);
+        // 내 소스코드
+        if (dirtyFilePath.endsWith(".ts") && !dirtyFilePath.endsWith(".d.ts")) {
+          const sourceFile = this._program.getSourceFile(dirtyFilePath);
+          if (!sourceFile) { // 삭제된 파일
+            changed = true;
+            continue;
+          }
 
           this._fileCache.set(dirtyFilePath, {
-            type: "aot",
+            type: "my",
             sourceFile,
-            ...new SdAotMetadataReader(metadataRoot).getMetadatas()
+            metadata: new SdMyMetadataReader(sourceFile, this._program).getMetadatas()
           });
           changed = true;
         }
-        else if (FsUtil.exists(sdMetadataFilePath)) {
-          const metadataRoot = await FsUtil.readJsonAsync(sdMetadataFilePath);
 
-          this._fileCache.set(dirtyFilePath, {
-            type: "aot",
-            sourceFile,
-            ...new SdAotMetadataReader(metadataRoot).getMetadatas()
+        // AOT 라이브러리
+        else if (dirtyFilePath.endsWith(".d.ts")) {
+          const sourceFile = this._program.getSourceFile(dirtyFilePath);
+          if (!sourceFile) { // 삭제된 파일
+            changed = true;
+            continue;
+          }
+
+          // from METADATA
+          const metadataFilePath = dirtyFilePath.replace(/\.d\.ts$/, ".metadata.json");
+          const sdMetadataFilePath = dirtyFilePath.replace(/\.d\.ts$/, ".sd-metadata.json");
+
+          if (FsUtil.exists(metadataFilePath)) {
+            const metadataRoot = await FsUtil.readJsonAsync(metadataFilePath);
+
+            this._fileCache.set(dirtyFilePath, {
+              type: "aot",
+              sourceFile,
+              ...new SdAotMetadataReader(metadataRoot).getMetadatas()
+            });
+            changed = true;
+          }
+          else if (FsUtil.exists(sdMetadataFilePath)) {
+            const metadataRoot = await FsUtil.readJsonAsync(sdMetadataFilePath);
+
+            this._fileCache.set(dirtyFilePath, {
+              type: "aot",
+              sourceFile,
+              ...new SdAotMetadataReader(metadataRoot).getMetadatas()
+            });
+            changed = true;
+          }
+
+          // from IVY
+          else {
+            this._fileCache.set(dirtyFilePath, {
+              type: "ivy",
+              sourceFile,
+              ...new SdIvyMetadataReader(sourceFile, ngProgram).getMetadatas()
+            });
+            changed = true;
+          }
+        }
+      }
+      catch (err) {
+        if (err instanceof SdMetadataError) {
+          result.push({
+            filePath: err.fileName,
+            severity: "error",
+            message: err.message
           });
-          changed = true;
         }
-
-        // from IVY
         else {
-          this._fileCache.set(dirtyFilePath, {
-            type: "ivy",
-            sourceFile,
-            ...new SdIvyMetadataReader(sourceFile, ngProgram).getMetadatas()
-          });
-          changed = true;
+          if (err instanceof Error) {
+            throw new SdError(err, "'" + dirtyFilePath + "' 메타데이터 로딩중 에러");
+          }
+          else {
+            throw err;
+          }
         }
       }
     }
@@ -120,29 +147,49 @@ export class SdCliNgModuleFilesGenerator {
   }
 
   public async generateAsync(): Promise<{ result: ISdPackageBuildResult[]; changedFilePaths: string[] }> {
-    let moduleInfoMap = this._getModuleInfoMap();
-    moduleInfoMap = this._mergeCircularModuleInfoMap(moduleInfoMap);
-
-    const routingModuleMap = await this._getRoutingModuleInfoMapAsync();
-
-    const changedFilePaths = [
-      ...await this._writeNgModuleFileAsync(moduleInfoMap),
-      ...await this._writeRoutingModuleFileAsync(moduleInfoMap, routingModuleMap)
-    ];
-
-    const genFilePaths = [...moduleInfoMap.keys(), ...routingModuleMap.keys()].distinct();
-    const delFilePaths = (await FsUtil.globAsync(path.resolve(this._moduleDistDirPath, "**", "*")))
-      .filter((item) => (
-        !genFilePaths.includes(PathUtil.posix(item))
-        && !genFilePaths.some((item1) => PathUtil.isChildPath(item1, item))
-      ))
-      .map((item) => PathUtil.posix(item));
-    for (const delFilePath of delFilePaths) {
-      changedFilePaths.push(delFilePath);
-      await FsUtil.removeAsync(delFilePath);
-    }
+    try {
+      let moduleInfoMap = this._getModuleInfoMap();
+      moduleInfoMap = this._mergeCircularModuleInfoMap(moduleInfoMap);
+
+      const routingModuleMap = await this._getRoutingModuleInfoMapAsync();
+
+      const changedFilePaths = [
+        ...await this._writeNgModuleFileAsync(moduleInfoMap),
+        ...await this._writeRoutingModuleFileAsync(moduleInfoMap, routingModuleMap)
+      ];
+
+      const genFilePaths = [...moduleInfoMap.keys(), ...routingModuleMap.keys()].distinct();
+      const delFilePaths = (await FsUtil.globAsync(path.resolve(this._moduleDistDirPath, "**", "*")))
+        .filter((item) => (
+          !genFilePaths.includes(PathUtil.posix(item))
+          && !genFilePaths.some((item1) => PathUtil.isChildPath(item1, item))
+        ))
+        .map((item) => PathUtil.posix(item));
+      for (const delFilePath of delFilePaths) {
+        changedFilePaths.push(delFilePath);
+        await FsUtil.removeAsync(delFilePath);
+      }
 
-    return { result: [], changedFilePaths: changedFilePaths.distinct() };
+      return { result: [], changedFilePaths: changedFilePaths.distinct() };
+    }
+    catch (err) {
+      if (err instanceof SdMetadataError) {
+        return {
+          result: [{
+            filePath: err.fileName,
+            severity: "error",
+            message: err.message
+          }],
+          changedFilePaths: []
+        };
+      }
+      else if (err instanceof Error) {
+        throw new SdError(err, "메타데이터 생성중 에러");
+      }
+      else {
+        throw err;
+      }
+    }
   }
 
   // region NgModule
@@ -512,7 +559,10 @@ export class ${moduleInfo.className} {
     const expFilePath = this._getResolvedFilePath(filePath, moduleName);
     if (StringUtil.isNullOrEmpty(expFilePath)) throw new NeverEntryError();
     const expFileCache = this._fileCache.get(expFilePath);
-    if (!expFileCache || expFileCache.type !== "aot") throw new NeverEntryError();
+    if (!expFileCache) {
+      throw new SdMetadataError(filePath, `'${filePath}'에서 '${moduleName}'에 대한 파일 '${expFilePath}'을 찾을 수 없습니다.`);
+    }
+    if (expFileCache.type !== "aot") throw new NeverEntryError();
     const newExp = expFileCache.exports.single((item) => (item.as ?? item.name) === targetName);
     if (!newExp) throw new NeverEntryError();
 
@@ -612,7 +662,7 @@ export class ${moduleInfo.className} {
       if (fileCache.type !== "my") continue;
 
       for (const metadata of fileCache.metadata) {
-        if (metadata.type !== "Component" || !metadata.className.endsWith("Page")) continue;
+        if (!metadata.className.endsWith("Page")) continue;
 
         const newRoutingModuleInfo: IGenRoutingModuleInfo = {
           path: "",
@@ -681,7 +731,6 @@ export class ${moduleInfo.className} {
       const moduleImportTexts: string[] = [];
 
       const pageFilePath = this._getModuleModuleImportName(path.dirname(distFilePath), routingModuleInfo.page.moduleFilePath);
-      moduleImportTexts.push(`import { ${routingModuleInfo.page.name} } from "${pageFilePath}";`);
 
       let content: string;
       if (path.basename(distFilePath) === "_routes.ts") {
@@ -697,6 +746,7 @@ export const routes: Routes = [
       else {
         moduleImportTexts.push(`import { NgModule } from "@angular/core";`);
         moduleImportTexts.push(`import { RouterModule } from "@angular/router";`);
+        moduleImportTexts.push(`import { ${routingModuleInfo.page.name} } from "${pageFilePath}";`);
 
         const thisPageModuleInfoEntry = Array.from(moduleInfoMap.entries())
           .single((item) => item[1].exports.some((exp) => exp.moduleFilePath === routingModuleInfo.page.moduleFilePath && exp.name === routingModuleInfo.page.name));
@@ -745,7 +795,9 @@ export class ${routingModuleInfo.page.name}RoutingModule {
   private _getRoutingModuleText(routingModuleInfo: IGenRoutingModuleInfo, distFilePath: string): string {
     let content = "{\r\n";
     content += `  path: "${routingModuleInfo.path}",\r\n`;
-    content += `  component: ${routingModuleInfo.page.name},\r\n`;
+    if (path.basename(distFilePath) !== "_routes.ts") {
+      content += `  component: ${routingModuleInfo.page.name},\r\n`;
+    }
     if (routingModuleInfo.children.length > 0) {
       content += `  children: [\r\n`;
       for (const child of routingModuleInfo.children) {

package/src/build-tools/metadata/SdAotMetadataReader.ts

@@ -4,6 +4,7 @@ import {
   isMetadataGlobalReferenceExpression,
   isMetadataImportedSymbolReferenceExpression,
   isMetadataSymbolicCallExpression,
+  isMetadataSymbolicIfExpression,
   isMetadataSymbolicReferenceExpression,
   MetadataEntry,
   MetadataObject,
@@ -18,7 +19,6 @@ export class SdAotMetadataReader {
 
   public getMetadatas(): IAotModuleDefMetadata {
     if (StringUtil.isNullOrEmpty(this._metadataRoot.importAs)) {
-      console.log(this._metadataRoot);
       throw new NeverEntryError();
     }
 
@@ -258,6 +258,9 @@ export class SdAotMetadataReader {
         );
         result.push(...subProvRefTargets);
       }
+      else if (isMetadataSymbolicIfExpression(refTarget.metadata)) {
+        result.push(...this._getProviderReferenceTargets([refTarget.metadata.thenExpression, refTarget.metadata.elseExpression]));
+      }
       else {
         throw new NeverEntryError();
       }

package/src/build-tools/metadata/SdIvyMetadataReader.ts

@@ -7,6 +7,8 @@ import { Reference } from "@angular/compiler-cli/src/ngtsc/imports";
 import { NgtscProgram } from "@angular/compiler-cli";
 import * as path from "path";
 import { INpmConfig } from "../../commons";
+import { IMyModuleImport } from "./SdMyMetadataReader";
+import { SdMetadataError } from "./SdMetadataError";
 
 export class SdIvyMetadataReader {
   private readonly _typeChecker: ts.TypeChecker;
@@ -76,7 +78,7 @@ export class SdIvyMetadataReader {
     return result;
   }
 
-  private _getAliasedModuleImportInfo(identifier: ts.Identifier): IIvyModuleImport {
+  private _getAliasedModuleImportInfo(identifier: ts.Identifier): IMyModuleImport {
     const moduleSymbol = this._typeChecker.getSymbolAtLocation(identifier);
     if (!moduleSymbol) throw new NeverEntryError();
     if (moduleSymbol.valueDeclaration) {
@@ -86,9 +88,18 @@ export class SdIvyMetadataReader {
     else {
       const aliasedTargetSymbol = this._typeChecker.getAliasedSymbol(moduleSymbol);
       const declarations = aliasedTargetSymbol.getDeclarations();
-      if (!declarations) throw new NeverEntryError();
-      const moduleFilePaths = declarations.map((item) => PathUtil.posix(item.getSourceFile().fileName)).distinct();
-      if (moduleFilePaths.length !== 1) throw new NeverEntryError();
+      if (!declarations || declarations.length < 1) {
+        throw new SdMetadataError(this._sourceFile.fileName, `'${identifier.text}'를 찾을 수 없습니다.`);
+      }
+      const moduleFilePaths = declarations
+        .filter((item) => (
+          this._hasParentsOrMe(item, (item1) => Boolean(item1.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)))
+        ))
+        .map((item) => PathUtil.posix(item.getSourceFile().fileName))
+        .distinct();
+      if (moduleFilePaths.length !== 1) {
+        throw new SdMetadataError(this._sourceFile.fileName, `'${identifier.text}'의 경로가 중복되었습니다.\n${moduleFilePaths.join("\n")}`);
+      }
 
       const moduleFilePath = moduleFilePaths[0];
 
@@ -96,6 +107,18 @@ export class SdIvyMetadataReader {
     }
   }
 
+  private _hasParentsOrMe(node: ts.Node, fn: (node1: ts.Node) => boolean): boolean {
+    let currNode = node as ts.Node | undefined;
+    while (true) {
+      if (!currNode) return false;
+
+      const result = fn(currNode);
+      if (result) return true;
+
+      currNode = currNode.parent as ts.Node | undefined;
+    }
+  }
+
   private getPackageName(): string {
     let cursorDirPath = path.dirname(this._sourceFile.fileName);
     while (true) {

package/src/build-tools/metadata/SdMetadataError.ts

@@ -0,0 +1,7 @@
+import { SdError } from "@simplysm/sd-core-common";
+
+export class SdMetadataError extends SdError {
+  public constructor(public fileName: string, public message: string) {
+    super(message);
+  }
+}

package/src/build-tools/metadata/SdMyMetadataReader.ts

@@ -1,6 +1,7 @@
 import * as ts from "typescript";
 import { NeverEntryError } from "@simplysm/sd-core-common";
 import { PathUtil } from "@simplysm/sd-core-node";
+import { SdMetadataError } from "./SdMetadataError";
 
 export class SdMyMetadataReader {
   private readonly _typeChecker: ts.TypeChecker;
@@ -150,9 +151,18 @@ export class SdMyMetadataReader {
     else {
       const aliasedTargetSymbol = this._typeChecker.getAliasedSymbol(moduleSymbol);
       const declarations = aliasedTargetSymbol.getDeclarations();
-      if (!declarations) throw new NeverEntryError();
-      const moduleFilePaths = declarations.map((item) => PathUtil.posix(item.getSourceFile().fileName)).distinct();
-      if (moduleFilePaths.length !== 1) throw new NeverEntryError();
+      if (!declarations || declarations.length < 1) {
+        throw new SdMetadataError(this._sourceFile.fileName, `'${identifier.text}'를 찾을 수 없습니다.`);
+      }
+      const moduleFilePaths = declarations
+        .filter((item) => (
+          this._hasParentsOrMe(item, (item1) => Boolean(item1.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)))
+        ))
+        .map((item) => PathUtil.posix(item.getSourceFile().fileName))
+        .distinct();
+      if (moduleFilePaths.length !== 1) {
+        throw new SdMetadataError(this._sourceFile.fileName, `'${identifier.text}'의 경로가 중복되었습니다.\n${moduleFilePaths.join("\n")}`);
+      }
 
       const moduleFilePath = moduleFilePaths[0];
 
@@ -160,6 +170,18 @@ export class SdMyMetadataReader {
     }
   }
 
+  private _hasParentsOrMe(node: ts.Node, fn: (node1: ts.Node) => boolean): boolean {
+    let currNode = node as ts.Node | undefined;
+    while (true) {
+      if (!currNode) return false;
+
+      const result = fn(currNode);
+      if (result) return true;
+
+      currNode = currNode.parent as ts.Node | undefined;
+    }
+  }
+
   private _getNgModuleDecoratorParam(decExp: ts.CallExpression): { exports: IMyModuleImport[]; providers: IMyModuleImport[] } {
     const result: { exports: IMyModuleImport[]; providers: IMyModuleImport[] } = {
       exports: [],