@nestia/sdk 4.4.2 → 4.5.0-dev.20241218

package/src/generates/internal/ImportDictionary.ts

@@ -1,147 +1,147 @@
-import path from "path";
-import { HashMap, HashSet, Pair } from "tstl";
-import ts from "typescript";
-
-import { FilePrinter } from "./FilePrinter";
-
-export class ImportDictionary {
-  private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
-    new HashMap();
-
-  public constructor(public readonly file: string) {}
-
-  public empty(): boolean {
-    return this.components_.empty();
-  }
-
-  public external(props: ImportDictionary.IExternalProps): string {
-    const composition: IComposition = this.components_.take(
-      new Pair(`node_modules/${props.library}`, props.type),
-      () => ({
-        location: `node_modules/${props.library}`,
-        elements: new HashSet(),
-        default: false,
-        type: props.type,
-      }),
-    );
-    if (props.instance === null) composition.default = true;
-    else composition.elements.insert(props.instance);
-    return props.instance ?? props.library;
-  }
-
-  public internal(props: ImportDictionary.IInternalProps): string {
-    const file: string = (() => {
-      if (props.file.substring(props.file.length - 5) === ".d.ts")
-        return props.file.substring(0, props.file.length - 5);
-      else if (props.file.substring(props.file.length - 3) === ".ts")
-        return props.file.substring(0, props.file.length - 3);
-      return props.file;
-    })();
-    const composition: IComposition = this.components_.take(
-      new Pair(file, props.type),
-      () => ({
-        location: file,
-        elements: new HashSet(),
-        default: false,
-        type: props.type,
-      }),
-    );
-    if (props.instance === null) {
-      composition.default = true;
-      if (props.name) composition.name = props.name;
-    } else composition.elements.insert(props.instance);
-    return props.instance ?? file;
-  }
-
-  public toStatements(outDir: string): ts.Statement[] {
-    const external: ts.ImportDeclaration[] = [];
-    const internal: ts.ImportDeclaration[] = [];
-
-    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: ts.ImportDeclaration[]) => {
-        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(
-            ts.factory.createImportDeclaration(
-              undefined,
-              ts.factory.createImportClause(
-                c.type,
-                c.default
-                  ? ts.factory.createIdentifier(c.name ?? c.location)
-                  : undefined,
-                c.elements.empty() === false
-                  ? ts.factory.createNamedImports(
-                      [...c.elements].map((elem) =>
-                        ts.factory.createImportSpecifier(
-                          false,
-                          undefined,
-                          ts.factory.createIdentifier(elem),
-                        ),
-                      ),
-                    )
-                  : undefined,
-              ),
-              ts.factory.createStringLiteral(c.location),
-            ),
-          );
-        }
-      };
-
-    enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
-    enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
-    return [
-      ...external,
-      ...(external.length && internal.length ? [FilePrinter.enter()] : []),
-      ...internal,
-    ];
-  }
-}
-export namespace ImportDictionary {
-  export interface IExternalProps {
-    type: boolean;
-    library: string;
-    instance: string | null;
-  }
-  export interface IInternalProps {
-    type: boolean;
-    file: string;
-    instance: string | null;
-    name?: string | null;
-  }
-}
-
-interface IComposition {
-  location: string;
-  type: boolean;
-  default: boolean;
-  name?: string;
-  elements: HashSet<string>;
-}
-
-const NODE_MODULES = "node_modules/";
+import path from "path";
+import { HashMap, HashSet, Pair } from "tstl";
+import ts from "typescript";
+
+import { FilePrinter } from "./FilePrinter";
+
+export class ImportDictionary {
+  private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
+    new HashMap();
+
+  public constructor(public readonly file: string) {}
+
+  public empty(): boolean {
+    return this.components_.empty();
+  }
+
+  public external(props: ImportDictionary.IExternalProps): string {
+    const composition: IComposition = this.components_.take(
+      new Pair(`node_modules/${props.library}`, props.type),
+      () => ({
+        location: `node_modules/${props.library}`,
+        elements: new HashSet(),
+        default: false,
+        type: props.type,
+      }),
+    );
+    if (props.instance === null) composition.default = true;
+    else composition.elements.insert(props.instance);
+    return props.instance ?? props.library;
+  }
+
+  public internal(props: ImportDictionary.IInternalProps): string {
+    const file: string = (() => {
+      if (props.file.substring(props.file.length - 5) === ".d.ts")
+        return props.file.substring(0, props.file.length - 5);
+      else if (props.file.substring(props.file.length - 3) === ".ts")
+        return props.file.substring(0, props.file.length - 3);
+      return props.file;
+    })();
+    const composition: IComposition = this.components_.take(
+      new Pair(file, props.type),
+      () => ({
+        location: file,
+        elements: new HashSet(),
+        default: false,
+        type: props.type,
+      }),
+    );
+    if (props.instance === null) {
+      composition.default = true;
+      if (props.name) composition.name = props.name;
+    } else composition.elements.insert(props.instance);
+    return props.instance ?? file;
+  }
+
+  public toStatements(outDir: string): ts.Statement[] {
+    const external: ts.ImportDeclaration[] = [];
+    const internal: ts.ImportDeclaration[] = [];
+
+    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: ts.ImportDeclaration[]) => {
+        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(
+            ts.factory.createImportDeclaration(
+              undefined,
+              ts.factory.createImportClause(
+                c.type,
+                c.default
+                  ? ts.factory.createIdentifier(c.name ?? c.location)
+                  : undefined,
+                c.elements.empty() === false
+                  ? ts.factory.createNamedImports(
+                      [...c.elements].map((elem) =>
+                        ts.factory.createImportSpecifier(
+                          false,
+                          undefined,
+                          ts.factory.createIdentifier(elem),
+                        ),
+                      ),
+                    )
+                  : undefined,
+              ),
+              ts.factory.createStringLiteral(c.location),
+            ),
+          );
+        }
+      };
+
+    enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
+    enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
+    return [
+      ...external,
+      ...(external.length && internal.length ? [FilePrinter.enter()] : []),
+      ...internal,
+    ];
+  }
+}
+export namespace ImportDictionary {
+  export interface IExternalProps {
+    type: boolean;
+    library: string;
+    instance: string | null;
+  }
+  export interface IInternalProps {
+    type: boolean;
+    file: string;
+    instance: string | null;
+    name?: string | null;
+  }
+}
+
+interface IComposition {
+  location: string;
+  type: boolean;
+  default: boolean;
+  name?: string;
+  elements: HashSet<string>;
+}
+
+const NODE_MODULES = "node_modules/";

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,185 +1,185 @@
-import ts from "typescript";
-import typia from "typia";
-import { TypeFactory } from "typia/lib/factories/TypeFactory";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-import { INestiaProject } from "../../structures/INestiaProject";
-import { IReflectHttpOperationParameter } from "../../structures/IReflectHttpOperationParameter";
-import { IReflectType } from "../../structures/IReflectType";
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-
-export namespace SdkAliasCollection {
-  export const name = ({ type }: { type: IReflectType }): ts.TypeNode =>
-    ts.factory.createTypeReferenceNode(
-      type.name,
-      type.typeArguments
-        ? type.typeArguments.map((a) => name({ type: a }))
-        : undefined,
-    );
-
-  export const from =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (metadata: Metadata) =>
-      SdkTypeProgrammer.write(project)(importer)(metadata);
-
-  export const headers =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IHeaders): ts.TypeNode => {
-      if (project.config.clone === true)
-        return from(project)(importer)(param.metadata);
-      const type: ts.TypeNode = name(param);
-      if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "typia",
-          instance: "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const query =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IQuery): ts.TypeNode => {
-      if (project.config.clone === true)
-        return from(project)(importer)(param.metadata);
-      const type: ts.TypeNode = name(param);
-      if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "typia",
-          instance: "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const input =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IBody): ts.TypeNode => {
-      if (project.config.clone === true) {
-        const type: ts.TypeNode = from(project)(importer)(param.metadata);
-        return param.contentType === "multipart/form-data"
-          ? formDataInput(importer)(type)
-          : type;
-      }
-      const type: ts.TypeNode = name(param);
-      if (param.contentType === "multipart/form-data")
-        return formDataInput(importer)(type);
-      else if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "typia",
-          instance:
-            typia.is<IReflectHttpOperationParameter.IBody>(param) &&
-            (param.contentType === "application/json" ||
-              param.encrypted === true)
-              ? "Primitive"
-              : "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const output =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode => {
-      const schema = (p: { metadata: Metadata; type: IReflectType }) =>
-        p.metadata.size() === 0
-          ? TypeFactory.keyword("void")
-          : project.config.clone === true
-            ? from(project)(importer)(p.metadata)
-            : project.config.primitive !== false
-              ? ts.factory.createTypeReferenceNode(
-                  importer.external({
-                    type: true,
-                    library: "typia",
-                    instance:
-                      route.success.contentType === "application/json" ||
-                      route.success.encrypted === true
-                        ? "Primitive"
-                        : "Resolved",
-                  }),
-                  [name(p)],
-                )
-              : name(p);
-      if (project.config.propagate !== true) return schema(route.success);
-
-      const branches: IBranch[] = [
-        {
-          status: String(
-            route.success.status ?? (route.method === "POST" ? 201 : 200),
-          ),
-          type: schema(route.success),
-        },
-        ...Object.entries(route.exceptions).map(([status, value]) => ({
-          status,
-          type: schema(value),
-        })),
-      ];
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "IPropagation",
-        }),
-        [
-          ts.factory.createTypeLiteralNode(
-            branches.map((b) =>
-              ts.factory.createPropertySignature(
-                undefined,
-                ts.factory.createNumericLiteral(b.status),
-                undefined,
-                b.type,
-              ),
-            ),
-          ),
-          ...(route.success.status
-            ? [
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createNumericLiteral(route.success.status),
-                ),
-              ]
-            : []),
-        ],
-      );
-    };
-
-  export const responseBody =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode =>
-      output({
-        ...project,
-        config: {
-          ...project.config,
-          propagate: false,
-        },
-      })(importer)(route);
-
-  const formDataInput = (importer: ImportDictionary) => (type: ts.TypeNode) =>
-    ts.factory.createTypeReferenceNode(
-      importer.external({
-        type: true,
-        library: "@nestia/fetcher",
-        instance: "FormDataInput",
-      }),
-      [type],
-    );
-}
-
-interface IBranch {
-  status: string;
-  type: ts.TypeNode;
-}
+import ts from "typescript";
+import typia from "typia";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { IReflectHttpOperationParameter } from "../../structures/IReflectHttpOperationParameter";
+import { IReflectType } from "../../structures/IReflectType";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkAliasCollection {
+  export const name = ({ type }: { type: IReflectType }): ts.TypeNode =>
+    ts.factory.createTypeReferenceNode(
+      type.name,
+      type.typeArguments
+        ? type.typeArguments.map((a) => name({ type: a }))
+        : undefined,
+    );
+
+  export const from =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (metadata: Metadata) =>
+      SdkTypeProgrammer.write(project)(importer)(metadata);
+
+  export const headers =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (param: ITypedHttpRouteParameter.IHeaders): ts.TypeNode => {
+      if (project.config.clone === true)
+        return from(project)(importer)(param.metadata);
+      const type: ts.TypeNode = name(param);
+      if (project.config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "typia",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const query =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (param: ITypedHttpRouteParameter.IQuery): ts.TypeNode => {
+      if (project.config.clone === true)
+        return from(project)(importer)(param.metadata);
+      const type: ts.TypeNode = name(param);
+      if (project.config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "typia",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const input =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (param: ITypedHttpRouteParameter.IBody): ts.TypeNode => {
+      if (project.config.clone === true) {
+        const type: ts.TypeNode = from(project)(importer)(param.metadata);
+        return param.contentType === "multipart/form-data"
+          ? formDataInput(importer)(type)
+          : type;
+      }
+      const type: ts.TypeNode = name(param);
+      if (param.contentType === "multipart/form-data")
+        return formDataInput(importer)(type);
+      else if (project.config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "typia",
+          instance:
+            typia.is<IReflectHttpOperationParameter.IBody>(param) &&
+            (param.contentType === "application/json" ||
+              param.encrypted === true)
+              ? "Primitive"
+              : "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const output =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): ts.TypeNode => {
+      const schema = (p: { metadata: Metadata; type: IReflectType }) =>
+        p.metadata.size() === 0
+          ? TypeFactory.keyword("void")
+          : project.config.clone === true
+            ? from(project)(importer)(p.metadata)
+            : project.config.primitive !== false
+              ? ts.factory.createTypeReferenceNode(
+                  importer.external({
+                    type: true,
+                    library: "typia",
+                    instance:
+                      route.success.contentType === "application/json" ||
+                      route.success.encrypted === true
+                        ? "Primitive"
+                        : "Resolved",
+                  }),
+                  [name(p)],
+                )
+              : name(p);
+      if (project.config.propagate !== true) return schema(route.success);
+
+      const branches: IBranch[] = [
+        {
+          status: String(
+            route.success.status ?? (route.method === "POST" ? 201 : 200),
+          ),
+          type: schema(route.success),
+        },
+        ...Object.entries(route.exceptions).map(([status, value]) => ({
+          status,
+          type: schema(value),
+        })),
+      ];
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "IPropagation",
+        }),
+        [
+          ts.factory.createTypeLiteralNode(
+            branches.map((b) =>
+              ts.factory.createPropertySignature(
+                undefined,
+                ts.factory.createNumericLiteral(b.status),
+                undefined,
+                b.type,
+              ),
+            ),
+          ),
+          ...(route.success.status
+            ? [
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createNumericLiteral(route.success.status),
+                ),
+              ]
+            : []),
+        ],
+      );
+    };
+
+  export const responseBody =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): ts.TypeNode =>
+      output({
+        ...project,
+        config: {
+          ...project.config,
+          propagate: false,
+        },
+      })(importer)(route);
+
+  const formDataInput = (importer: ImportDictionary) => (type: ts.TypeNode) =>
+    ts.factory.createTypeReferenceNode(
+      importer.external({
+        type: true,
+        library: "@nestia/fetcher",
+        instance: "FormDataInput",
+      }),
+      [type],
+    );
+}
+
+interface IBranch {
+  status: string;
+  type: ts.TypeNode;
+}