@nestia/sdk 3.1.0-dev.20240429 → 3.1.0-dev.20240430

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,157 +1,157 @@
-import ts from "typescript";
-import typia from "typia";
-
-import { INestiaProject } from "../../structures/INestiaProject";
-import { IReflectHttpOperation } from "../../structures/IReflectHttpOperation";
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-
-export namespace SdkAliasCollection {
-  export const name =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput): ts.TypeNode =>
-      p.metadata
-        ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
-        : ts.factory.createTypeReferenceNode(p.typeName);
-
-  export const headers =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(project)(importer)(param);
-      if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const query =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(project)(importer)(param);
-      if (project.config.primitive === false) return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance: "Resolved",
-        }),
-        [type],
-      );
-    };
-
-  export const input =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
-      const type: ts.TypeNode = name(project)(importer)(param);
-      if (project.config.clone === true || project.config.primitive === false)
-        return type;
-      return ts.factory.createTypeReferenceNode(
-        importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance:
-            typia.is<IReflectHttpOperation.IBodyParameter>(param) &&
-            param.contentType === "multipart/form-data"
-              ? "Resolved"
-              : "Primitive",
-        }),
-        [type],
-      );
-    };
-
-  export const output =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode => {
-      if (project.config.propagate !== true) {
-        const node: ts.TypeNode = name(project)(importer)(route.output);
-        const type = project.checker.getTypeAtLocation(node);
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-
-        if (
-          project.config.clone === true ||
-          project.config.primitive === false ||
-          filter(ts.TypeFlags.Undefined) ||
-          filter(ts.TypeFlags.Never) ||
-          filter(ts.TypeFlags.Void) ||
-          filter(ts.TypeFlags.VoidLike)
-        )
-          return node;
-        return ts.factory.createTypeReferenceNode(
-          importer.external({
-            type: true,
-            library: "@nestia/fetcher",
-            instance:
-              route.output.contentType === "application/x-www-form-urlencoded"
-                ? "Resolved"
-                : "Primitive",
-          }),
-          [node],
-        );
-      }
-
-      const branches: IBranch[] = [
-        {
-          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
-          type: name(project)(importer)(route.output),
-        },
-        ...Object.entries(route.exceptions).map(([status, value]) => ({
-          status,
-          type: name(project)(importer)(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.status
-            ? [
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createNumericLiteral(route.status),
-                ),
-              ]
-            : []),
-        ],
-      );
-    };
-
-  export const responseBody =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeNode =>
-      output({
-        ...project,
-        config: {
-          ...project.config,
-          propagate: false,
-        },
-      })(importer)(route);
-}
-
-interface IBranch {
-  status: string;
-  type: ts.TypeNode;
-}
+import ts from "typescript";
+import typia from "typia";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { IReflectHttpOperation } from "../../structures/IReflectHttpOperation";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkAliasCollection {
+  export const name =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput): ts.TypeNode =>
+      p.metadata
+        ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
+        : ts.factory.createTypeReferenceNode(p.typeName);
+
+  export const headers =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(project)(importer)(param);
+      if (project.config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const query =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(project)(importer)(param);
+      if (project.config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const input =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (param: ITypedHttpRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(project)(importer)(param);
+      if (project.config.clone === true || project.config.primitive === false)
+        return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance:
+            typia.is<IReflectHttpOperation.IBodyParameter>(param) &&
+            param.contentType === "multipart/form-data"
+              ? "Resolved"
+              : "Primitive",
+        }),
+        [type],
+      );
+    };
+
+  export const output =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): ts.TypeNode => {
+      if (project.config.propagate !== true) {
+        const node: ts.TypeNode = name(project)(importer)(route.output);
+        const type = project.checker.getTypeAtLocation(node);
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+
+        if (
+          project.config.clone === true ||
+          project.config.primitive === false ||
+          filter(ts.TypeFlags.Undefined) ||
+          filter(ts.TypeFlags.Never) ||
+          filter(ts.TypeFlags.Void) ||
+          filter(ts.TypeFlags.VoidLike)
+        )
+          return node;
+        return ts.factory.createTypeReferenceNode(
+          importer.external({
+            type: true,
+            library: "@nestia/fetcher",
+            instance:
+              route.output.contentType === "application/x-www-form-urlencoded"
+                ? "Resolved"
+                : "Primitive",
+          }),
+          [node],
+        );
+      }
+
+      const branches: IBranch[] = [
+        {
+          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
+          type: name(project)(importer)(route.output),
+        },
+        ...Object.entries(route.exceptions).map(([status, value]) => ({
+          status,
+          type: name(project)(importer)(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.status
+            ? [
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createNumericLiteral(route.status),
+                ),
+              ]
+            : []),
+        ],
+      );
+    };
+
+  export const responseBody =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): ts.TypeNode =>
+      output({
+        ...project,
+        config: {
+          ...project.config,
+          propagate: false,
+        },
+      })(importer)(route);
+}
+
+interface IBranch {
+  status: string;
+  type: ts.TypeNode;
+}

package/src/generates/internal/SdkDistributionComposer.ts

@@ -1,100 +1,100 @@
-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 (config: INestiaConfig, websocket: boolean) => {
-    if (!fs.existsSync(config.distribute!))
-      await fs.promises.mkdir(config.distribute!);
-
-    const root: string = process.cwd();
-    const output: string = path.resolve(config.output!);
-    process.chdir(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 versions: IDependencies = await dependencies();
-    execute("npm install --save-dev rimraf");
-    execute(
-      `npm install --save @nestia/fetcher@${versions["@nestia/fetcher"]}`,
-    );
-    execute(`npm install --save typia@${versions["typia"]}`);
-    if (websocket) execute(`npm install --save tgrid@${versions["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: {
-      dependencies: Record<string, string>;
-      devDependencies: Record<string, string>;
-    } = JSON.parse(content);
-    return typia.assert<IDependencies>({
-      ...json.devDependencies,
-      ...json.dependencies,
-    });
-  };
-}
-
-interface IDependencies {
-  "@nestia/fetcher": 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 (config: INestiaConfig, websocket: boolean) => {
+    if (!fs.existsSync(config.distribute!))
+      await fs.promises.mkdir(config.distribute!);
+
+    const root: string = process.cwd();
+    const output: string = path.resolve(config.output!);
+    process.chdir(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 versions: IDependencies = await dependencies();
+    execute("npm install --save-dev rimraf");
+    execute(
+      `npm install --save @nestia/fetcher@${versions["@nestia/fetcher"]}`,
+    );
+    execute(`npm install --save typia@${versions["typia"]}`);
+    if (websocket) execute(`npm install --save tgrid@${versions["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: {
+      dependencies: Record<string, string>;
+      devDependencies: Record<string, string>;
+    } = JSON.parse(content);
+    return typia.assert<IDependencies>({
+      ...json.devDependencies,
+      ...json.dependencies,
+    });
+  };
+}
+
+interface IDependencies {
+  "@nestia/fetcher": string;
+  typia: string;
+  tgrid: string;
+}
+const BUNDLE = __dirname + "/../../../assets/bundle/distribute";