@nestia/sdk 2.5.0-dev.20240130-3 → 2.5.0-dev.20240130-5

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,11 +1,10 @@
-import fs from "fs";
 import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
-import { FormatUtil } from "../../utils/FormatUtil";
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
@@ -35,26 +34,14 @@ export namespace E2eFileProgrammer {
       });
 
       const functor = generate_function(checker)(config)(importer)(route);
-
-      await fs.promises.writeFile(
-        importer.file,
-        await FormatUtil.beautify(
-          ts
-            .createPrinter()
-            .printFile(
-              ts.factory.createSourceFile(
-                [
-                  ...importer.toStatements(props.current),
-                  FormatUtil.enter(),
-                  functor,
-                ],
-                ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
-                ts.NodeFlags.None,
-              ),
-            ),
-        ),
-        "utf8",
-      );
+      await FilePrinter.write({
+        location: importer.file,
+        statements: [
+          ...importer.toStatements(props.current),
+          FilePrinter.enter(),
+          functor,
+        ],
+      });
     };
 
   const generate_function =
@@ -187,5 +174,5 @@ const getTypeName =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/FilePrinter.ts

@@ -0,0 +1,53 @@
+import fs from "fs";
+import { format } from "prettier";
+import ts from "typescript";
+
+export namespace FilePrinter {
+  export const description = <Node extends ts.Node>(
+    node: Node,
+    comment: string,
+  ): Node => {
+    if (comment.length === 0) return node;
+    ts.addSyntheticLeadingComment(
+      node,
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      ["*", ...comment.split("\n").map((str) => ` * ${str}`), ""].join("\n"),
+      true,
+    );
+    return node;
+  };
+
+  export const enter = () =>
+    ts.factory.createExpressionStatement(ts.factory.createIdentifier("\n"));
+
+  export const write = async (props: {
+    location: string;
+    statements: ts.Statement[];
+    top?: string;
+  }): Promise<void> => {
+    const script: string = ts
+      .createPrinter()
+      .printFile(
+        ts.factory.createSourceFile(
+          props.statements,
+          ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
+          ts.NodeFlags.None,
+        ),
+      );
+    await fs.promises.writeFile(
+      props.location,
+      await beautify((props.top ?? "") + script),
+      "utf8",
+    );
+  };
+
+  const beautify = async (script: string): Promise<string> => {
+    try {
+      return await format(script, {
+        parser: "typescript",
+      });
+    } catch {
+      return script;
+    }
+  };
+}

package/src/{utils → generates/internal}/ImportDictionary.ts

@@ -4,7 +4,7 @@ import { HashSet } from "tstl/container/HashSet";
 import { Pair } from "tstl/utility/Pair";
 import ts from "typescript";
 
-import { FormatUtil } from "./FormatUtil";
+import { FilePrinter } from "./FilePrinter";
 
 export class ImportDictionary {
   private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
@@ -119,58 +119,10 @@ export class ImportDictionary {
     enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
     return [
       ...external,
-      ...(external.length && internal.length ? [FormatUtil.enter()] : []),
+      ...(external.length && internal.length ? [FilePrinter.enter()] : []),
       ...internal,
     ];
   }
-
-  public toScript(outDir: string): string {
-    const external: string[] = [];
-    const internal: string[] = [];
-
-    const locator = (str: string) => {
-      const location: string = path.relative(outDir, str).split("\\").join("/");
-      const index: number = location.lastIndexOf(NODE_MODULES);
-      return index === -1
-        ? location.startsWith("..")
-          ? location
-          : `./${location}`
-        : location.substring(index + NODE_MODULES.length);
-    };
-    const enroll =
-      (filter: (str: string) => boolean) => (container: string[]) => {
-        const compositions: IComposition[] = this.components_
-          .toJSON()
-          .filter((c) => filter(c.second.location))
-          .map((e) => ({
-            ...e.second,
-            location: locator(e.second.location),
-          }))
-          .sort((a, b) => a.location.localeCompare(b.location));
-        for (const c of compositions) {
-          const brackets: string[] = [];
-          if (c.default) brackets.push(c.name ?? c.location);
-          if (c.elements.empty() === false)
-            brackets.push(
-              `{ ${c.elements
-                .toJSON()
-                .sort((a, b) => a.localeCompare(b))
-                .join(", ")} }`,
-            );
-          container.push(
-            `import ${c.type ? "type " : ""}${brackets.join(", ")} from "${
-              c.location
-            }";`,
-          );
-        }
-      };
-
-    enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
-    enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
-
-    if (external.length && internal.length) external.push("");
-    return [...external, ...internal].join("\n");
-  }
 }
 export namespace ImportDictionary {
   export interface IExternalProps {

package/src/generates/internal/SdkAliasCollection.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkAliasCollection {
@@ -11,7 +11,7 @@ export namespace SdkAliasCollection {
     (importer: ImportDictionary) =>
     (p: IRoute.IParameter | IRoute.IOutput): ts.TypeNode =>
       p.metadata
-        ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+        ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
         : ts.factory.createTypeReferenceNode(p.typeName);
 
   export const headers =

package/src/generates/internal/SdkFileProgrammer.ts

@@ -3,9 +3,9 @@ import ts from "typescript";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
-import { FormatUtil } from "../../utils/FormatUtil";
-import { ImportDictionary } from "../../utils/ImportDictionary";
 import { MapUtil } from "../../utils/MapUtil";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkRouteDirectory } from "./SdkRouteDirectory";
 import { SdkRouteProgrammer } from "./SdkRouteProgrammer";
 
@@ -69,7 +69,7 @@ export namespace SdkFileProgrammer {
         );
       }
       if (statements.length && directory.routes.length)
-        statements.push(FormatUtil.enter());
+        statements.push(FilePrinter.enter());
 
       // ITERATE ROUTES
       const importer: ImportDictionary = new ImportDictionary(
@@ -97,7 +97,7 @@ export namespace SdkFileProgrammer {
           ...SdkRouteProgrammer.generate(checker)(config)(importer)(route),
         );
         if (i !== directory.routes.length - 1)
-          statements.push(FormatUtil.enter());
+          statements.push(FilePrinter.enter());
       });
 
       // FINALIZE THE CONTENT
@@ -105,31 +105,20 @@ export namespace SdkFileProgrammer {
         statements.push(
           ...importer.toStatements(outDir),
           ...(!importer.empty() && statements.length
-            ? [FormatUtil.enter()]
+            ? [FilePrinter.enter()]
             : []),
           ...statements.splice(0, statements.length),
         );
-
-      const script: string =
-        "/**\n" +
-        " * @packageDocumentation\n" +
-        ` * @module ${directory.module}\n` +
-        " * @nestia Generated by Nestia - https://github.com/samchon/nestia \n" +
-        " */\n" +
-        "//================================================================\n" +
-        ts
-          .createPrinter()
-          .printFile(
-            ts.factory.createSourceFile(
-              statements,
-              ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
-              ts.NodeFlags.None,
-            ),
-          );
-      await fs.promises.writeFile(
-        importer.file,
-        await FormatUtil.beautify(script),
-        "utf8",
-      );
+      await FilePrinter.write({
+        location: importer.file,
+        statements,
+        top:
+          "/**\n" +
+          " * @packageDocumentation\n" +
+          ` * @module ${directory.module}\n` +
+          " * @nestia Generated by Nestia - https://github.com/samchon/nestia \n" +
+          " */\n" +
+          "//================================================================\n",
+      });
     };
 }

package/src/generates/internal/SdkFunctionProgrammer.ts

@@ -5,7 +5,7 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { INestiaConfig } from "../../INestiaConfig";
 import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
@@ -215,5 +215,5 @@ const getTypeName =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkImportWizard.ts

@@ -1,4 +1,4 @@
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { ImportDictionary } from "./ImportDictionary";
 
 export namespace SdkImportWizard {
   export const Fetcher = (encrypted: boolean) =>

package/src/generates/internal/SdkInterfaceProgrammer.ts

@@ -11,9 +11,9 @@ import { Escaper } from "typia/lib/utils/Escaper";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
-import { FormatUtil } from "../../utils/FormatUtil";
-import { ImportDictionary } from "../../utils/ImportDictionary";
 import { MapUtil } from "../../utils/MapUtil";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkInterfaceProgrammer {
@@ -25,7 +25,7 @@ export namespace SdkInterfaceProgrammer {
       | ((importer: ImportDictionary) => ts.TypeAliasDeclaration);
   }
 
-  export const generate =
+  export const write =
     (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (routes: IRoute[]): Map<string, IModule> => {
@@ -60,12 +60,13 @@ export namespace SdkInterfaceProgrammer {
       const dict: Map<string, IModule> = new Map();
       for (const alias of collection.aliases())
         prepare(dict)(alias.name)((importer) =>
-          define_alias(config)(importer)(alias),
+          write_alias(config)(importer)(alias),
         );
       for (const object of collection.objects())
-        prepare(dict)(object.name)((importer) =>
-          define_object(config)(importer)(object),
-        );
+        if (object.name !== "__type" && !object.name.startsWith("__type."))
+          prepare(dict)(object.name)((importer) =>
+            write_object(config)(importer)(object),
+          );
       return dict;
     };
 
@@ -88,53 +89,53 @@ export namespace SdkInterfaceProgrammer {
       return modulo!;
     };
 
-  const define_alias =
+  const write_alias =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (alias: MetadataAlias): ts.TypeAliasDeclaration =>
-      FormatUtil.description(
+      FilePrinter.description(
         ts.factory.createTypeAliasDeclaration(
           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
           alias.name.split(".").at(-1)!,
           [],
-          SdkTypeProgrammer.decode(config)(importer)(alias.value),
+          SdkTypeProgrammer.write(config)(importer)(alias.value),
         ),
         writeComment([])(alias.description, alias.jsDocTags),
       );
 
-  const define_object =
+  const write_object =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (object: MetadataObject): ts.TypeAliasDeclaration => {
       const regular = object.properties.filter((p) => p.key.isSoleLiteral());
       const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
-      return FormatUtil.description(
+      return FilePrinter.description(
         ts.factory.createTypeAliasDeclaration(
           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
           object.name.split(".").at(-1)!,
           [],
           regular.length && dynamic.length
             ? ts.factory.createIntersectionTypeNode([
-                define_regular(config)(importer)(regular),
-                ...dynamic.map(define_dynamic(config)(importer)),
+                write_regular(config)(importer)(regular),
+                ...dynamic.map(write_dynamic(config)(importer)),
               ])
             : dynamic.length
               ? ts.factory.createIntersectionTypeNode(
-                  dynamic.map(define_dynamic(config)(importer)),
+                  dynamic.map(write_dynamic(config)(importer)),
                 )
-              : define_regular(config)(importer)(regular),
+              : write_regular(config)(importer)(regular),
         ),
         writeComment([])(object.description ?? null, object.jsDocTags),
       );
     };
 
-  const define_regular =
+  const write_regular =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (properties: MetadataProperty[]): ts.TypeLiteralNode =>
       ts.factory.createTypeLiteralNode(
         properties.map((p) =>
-          FormatUtil.description(
+          FilePrinter.description(
             ts.factory.createPropertySignature(
               undefined,
               Escaper.variable(String(p.key.constants[0].values[0]))
@@ -147,19 +148,19 @@ export namespace SdkInterfaceProgrammer {
               p.value.isRequired() === false
                 ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                 : undefined,
-              SdkTypeProgrammer.decode(config)(importer)(p.value),
+              SdkTypeProgrammer.write(config)(importer)(p.value),
             ),
             writeComment(p.value.atomics)(p.description, p.jsDocTags),
           ),
         ),
       );
 
-  const define_dynamic =
+  const write_dynamic =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (property: MetadataProperty): ts.TypeLiteralNode =>
       ts.factory.createTypeLiteralNode([
-        FormatUtil.description(
+        FilePrinter.description(
           ts.factory.createIndexSignature(
             undefined,
             [
@@ -168,10 +169,10 @@ export namespace SdkInterfaceProgrammer {
                 undefined,
                 ts.factory.createIdentifier("key"),
                 undefined,
-                SdkTypeProgrammer.decode(config)(importer)(property.key),
+                SdkTypeProgrammer.write(config)(importer)(property.key),
               ),
             ],
-            SdkTypeProgrammer.decode(config)(importer)(property.value),
+            SdkTypeProgrammer.write(config)(importer)(property.value),
           ),
           writeComment(property.value.atomics)(
             property.description,

package/src/generates/internal/SdkNamespaceProgrammer.ts

@@ -9,15 +9,15 @@ import { Escaper } from "typia/lib/utils/Escaper";
 import { INestiaConfig } from "../../INestiaConfig";
 import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
-import { FormatUtil } from "../../utils/FormatUtil";
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkSimulationProgrammer } from "./SdkSimulationProgrammer";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+import { FilePrinter } from "./FilePrinter";
 
 export namespace SdkNamespaceProgrammer {
-  export const generate =
+  export const write =
     (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
@@ -29,16 +29,16 @@ export namespace SdkNamespaceProgrammer {
         input: IRoute.IParameter | undefined;
       },
     ): ts.ModuleDeclaration => {
-      const types = generate_types(checker)(config)(importer)(route, props);
+      const types = write_types(checker)(config)(importer)(route, props);
       return ts.factory.createModuleDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createIdentifier(route.name),
         ts.factory.createModuleBlock([
           ...types,
-          ...(types.length ? [FormatUtil.enter()] : []),
-          generate_metadata(importer)(route, props),
-          FormatUtil.enter(),
-          generate_path(config)(importer)(route, props),
+          ...(types.length ? [FilePrinter.enter()] : []),
+          write_metadata(importer)(route, props),
+          FilePrinter.enter(),
+          write_path(config)(importer)(route, props),
           ...(config.simulate
             ? [
                 SdkSimulationProgrammer.random(checker)(config)(importer)(
@@ -51,14 +51,14 @@ export namespace SdkNamespaceProgrammer {
               ]
             : []),
           ...(config.json && props.input?.category === "body"
-            ? [generate_stringify(config)(importer)]
+            ? [write_stringify(config)(importer)]
             : []),
         ]),
         ts.NodeFlags.Namespace,
       );
     };
 
-  const generate_types =
+  const write_types =
     (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
@@ -103,7 +103,7 @@ export namespace SdkNamespaceProgrammer {
       return array;
     };
 
-  const generate_metadata =
+  const write_metadata =
     (importer: ImportDictionary) =>
     (
       route: IRoute,
@@ -184,7 +184,7 @@ export namespace SdkNamespaceProgrammer {
         ),
       );
 
-  const generate_path =
+  const write_path =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
     (
@@ -440,7 +440,7 @@ export namespace SdkNamespaceProgrammer {
       );
     };
 
-  const generate_stringify =
+  const write_stringify =
     (config: INestiaConfig) =>
     (importer: ImportDictionary): ts.VariableStatement =>
       constant("stringify")(
@@ -503,5 +503,5 @@ const getType =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkRouteProgrammer.ts

@@ -3,10 +3,10 @@ import { IJsDocTagInfo } from "typia";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
-import { FormatUtil } from "../../utils/FormatUtil";
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
 import { SdkNamespaceProgrammer } from "./SdkNamespaceProgrammer";
+import { FilePrinter } from "./FilePrinter";
 
 export namespace SdkRouteProgrammer {
   export const generate =
@@ -24,14 +24,11 @@ export namespace SdkRouteProgrammer {
         input: route.parameters.find((p) => p.category === "body"),
       };
       return [
-        FormatUtil.description(
+        FilePrinter.description(
           SdkFunctionProgrammer.generate(config)(importer)(route, props),
           describe(route),
         ),
-        SdkNamespaceProgrammer.generate(checker)(config)(importer)(
-          route,
-          props,
-        ),
+        SdkNamespaceProgrammer.write(checker)(config)(importer)(route, props),
       ];
     };
 

package/src/generates/internal/SdkSimulationProgrammer.ts

@@ -7,7 +7,7 @@ import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
+import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
@@ -353,5 +353,5 @@ const getTypeName =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
       : ts.factory.createTypeReferenceNode(p.typeName);