@nestia/sdk 6.0.6 → 7.0.0-dev.20250605

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,185 +1,204 @@
-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 props =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): ts.TypeNode =>
+      ts.factory.createTypeLiteralNode(
+        route.parameters
+          .filter((p) => p.category !== "headers")
+          .map((param) =>
+            ts.factory.createPropertySignature(
+              undefined,
+              param.name,
+              param.metadata.isRequired() === false
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined,
+              SdkTypeProgrammer.write(project)(importer)(param.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 body =
+    (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 response =
+    (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 =>
+      response({
+        ...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;
+}

package/src/generates/internal/SdkDistributionComposer.ts

@@ -1,103 +1,103 @@
-import cp from "child_process";
-import fs from "fs";
-import path from "path";
-import typia from "typia";
-
-import { INestiaConfig } from "../../INestiaConfig";
-
-export namespace SdkDistributionComposer {
-  export const compose = async (props: {
-    config: INestiaConfig;
-    websocket: boolean;
-  }) => {
-    if (!fs.existsSync(props.config.distribute!))
-      await fs.promises.mkdir(props.config.distribute!);
-
-    const root: string = process.cwd();
-    const output: string = path.resolve(props.config.output!);
-    process.chdir(props.config.distribute!);
-
-    const exit = () => process.chdir(root);
-    if (await configured()) return exit();
-
-    // COPY FILES
-    console.log("Composing SDK distribution environments...");
-    for (const file of await fs.promises.readdir(BUNDLE))
-      await fs.promises.copyFile(`${BUNDLE}/${file}`, file);
-
-    // CONFIGURE PATHS
-    for (const file of ["package.json", "tsconfig.json"])
-      await replace({ root, output })(file);
-
-    // INSTALL PACKAGES
-    const v: IDependencies = await dependencies();
-    execute("npm install --save-dev rimraf");
-    execute(`npm install --save @nestia/fetcher@${v.version}`);
-    execute(`npm install --save typia@${v.typia}`);
-    if (props.websocket) execute(`npm install --save tgrid@${v.tgrid}`);
-    execute("npx typia setup --manager npm");
-
-    exit();
-  };
-
-  const configured = async (): Promise<boolean> =>
-    ["package.json", "tsconfig.json"].every(fs.existsSync) &&
-    (await (async () => {
-      const content = JSON.parse(
-        await fs.promises.readFile("package.json", "utf8"),
-      );
-      return !!content.dependencies?.["@nestia/fetcher"];
-    })());
-
-  const execute = (command: string) => {
-    console.log(`  - ${command}`);
-    cp.execSync(command, { stdio: "ignore" });
-  };
-
-  const replace =
-    (props: { root: string; output: string }) =>
-    async (file: string): Promise<void> => {
-      const relative = (from: string) => (to: string) =>
-        path.relative(from, to).split("\\").join("/");
-      const root: string = relative(process.cwd())(props.root);
-      const output: string = relative(process.cwd())(props.output);
-      const current: string = relative(props.root)(process.cwd());
-
-      const content: string = await fs.promises.readFile(file, "utf8");
-      await fs.promises.writeFile(
-        file,
-        content
-          .split("${root}")
-          .join(root)
-          .split("${output}")
-          .join(output)
-          .split("${current}")
-          .join(current),
-        "utf8",
-      );
-    };
-
-  const dependencies = async (): Promise<IDependencies> => {
-    const content: string = await fs.promises.readFile(
-      __dirname + "/../../../package.json",
-      "utf8",
-    );
-    const json: {
-      version: string;
-      dependencies: Record<string, string>;
-      devDependencies: Record<string, string>;
-    } = JSON.parse(content);
-    return typia.assert<IDependencies>({
-      ...json.devDependencies,
-      ...json.dependencies,
-      version: json.version,
-    });
-  };
-}
-
-interface IDependencies {
-  version: string;
-  typia: string;
-  tgrid: string;
-}
-const BUNDLE = __dirname + "/../../../assets/bundle/distribute";
+import cp from "child_process";
+import fs from "fs";
+import path from "path";
+import typia from "typia";
+
+import { INestiaConfig } from "../../INestiaConfig";
+
+export namespace SdkDistributionComposer {
+  export const compose = async (props: {
+    config: INestiaConfig;
+    websocket: boolean;
+  }) => {
+    if (!fs.existsSync(props.config.distribute!))
+      await fs.promises.mkdir(props.config.distribute!);
+
+    const root: string = process.cwd();
+    const output: string = path.resolve(props.config.output!);
+    process.chdir(props.config.distribute!);
+
+    const exit = () => process.chdir(root);
+    if (await configured()) return exit();
+
+    // COPY FILES
+    console.log("Composing SDK distribution environments...");
+    for (const file of await fs.promises.readdir(BUNDLE))
+      await fs.promises.copyFile(`${BUNDLE}/${file}`, file);
+
+    // CONFIGURE PATHS
+    for (const file of ["package.json", "tsconfig.json"])
+      await replace({ root, output })(file);
+
+    // INSTALL PACKAGES
+    const v: IDependencies = await dependencies();
+    execute("npm install --save-dev rimraf");
+    execute(`npm install --save @nestia/fetcher@${v.version}`);
+    execute(`npm install --save typia@${v.typia}`);
+    if (props.websocket) execute(`npm install --save tgrid@${v.tgrid}`);
+    execute("npx typia setup --manager npm");
+
+    exit();
+  };
+
+  const configured = async (): Promise<boolean> =>
+    ["package.json", "tsconfig.json"].every(fs.existsSync) &&
+    (await (async () => {
+      const content = JSON.parse(
+        await fs.promises.readFile("package.json", "utf8"),
+      );
+      return !!content.dependencies?.["@nestia/fetcher"];
+    })());
+
+  const execute = (command: string) => {
+    console.log(`  - ${command}`);
+    cp.execSync(command, { stdio: "ignore" });
+  };
+
+  const replace =
+    (props: { root: string; output: string }) =>
+    async (file: string): Promise<void> => {
+      const relative = (from: string) => (to: string) =>
+        path.relative(from, to).split("\\").join("/");
+      const root: string = relative(process.cwd())(props.root);
+      const output: string = relative(process.cwd())(props.output);
+      const current: string = relative(props.root)(process.cwd());
+
+      const content: string = await fs.promises.readFile(file, "utf8");
+      await fs.promises.writeFile(
+        file,
+        content
+          .split("${root}")
+          .join(root)
+          .split("${output}")
+          .join(output)
+          .split("${current}")
+          .join(current),
+        "utf8",
+      );
+    };
+
+  const dependencies = async (): Promise<IDependencies> => {
+    const content: string = await fs.promises.readFile(
+      __dirname + "/../../../package.json",
+      "utf8",
+    );
+    const json: {
+      version: string;
+      dependencies: Record<string, string>;
+      devDependencies: Record<string, string>;
+    } = JSON.parse(content);
+    return typia.assert<IDependencies>({
+      ...json.devDependencies,
+      ...json.dependencies,
+      version: json.version,
+    });
+  };
+}
+
+interface IDependencies {
+  version: string;
+  typia: string;
+  tgrid: string;
+}
+const BUNDLE = __dirname + "/../../../assets/bundle/distribute";