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

package/src/generates/SdkGenerator.ts

@@ -1,91 +1,91 @@
-import fs from "fs";
-import NodePath from "path";
-import { IPointer } from "tstl";
-
-import { INestiaProject } from "../structures/INestiaProject";
-import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
-import { CloneGenerator } from "./CloneGenerator";
-import { SdkDistributionComposer } from "./internal/SdkDistributionComposer";
-import { SdkFileProgrammer } from "./internal/SdkFileProgrammer";
-
-export namespace SdkGenerator {
-  export const generate =
-    (project: INestiaProject) =>
-    async (
-      routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
-    ): Promise<void> => {
-      console.log("Generating SDK Library");
-
-      // PREPARE NEW DIRECTORIES
-      try {
-        await fs.promises.mkdir(project.config.output!);
-      } catch {}
-
-      // BUNDLING
-      const bundle: string[] = await fs.promises.readdir(BUNDLE_PATH);
-      for (const file of bundle) {
-        const current: string = `${BUNDLE_PATH}/${file}`;
-        const target: string = `${project.config.output}/${file}`;
-        const stats: fs.Stats = await fs.promises.stat(current);
-
-        if (stats.isFile() === true) {
-          const content: string = await fs.promises.readFile(current, "utf8");
-          if (fs.existsSync(target) === false)
-            await fs.promises.writeFile(target, content, "utf8");
-          else if (BUNDLE_CHANGES[file] !== undefined) {
-            const r: IPointer<string> = {
-              value: await fs.promises.readFile(target, "utf8"),
-            };
-            for (const [before, after] of BUNDLE_CHANGES[file])
-              r.value = r.value.replace(before, after);
-            await fs.promises.writeFile(target, r.value, "utf8");
-          }
-        }
-      }
-
-      // STRUCTURES
-      if (project.config.clone)
-        await CloneGenerator.write(project)(
-          routes.filter((r) => r.protocol === "http") as ITypedHttpRoute[],
-        );
-
-      // FUNCTIONAL
-      await SdkFileProgrammer.generate(project)(routes);
-
-      // DISTRIBUTION
-      if (project.config.distribute !== undefined)
-        await SdkDistributionComposer.compose(
-          project.config,
-          routes.some((r) => r.protocol === "websocket"),
-        );
-    };
-
-  export const BUNDLE_PATH = NodePath.join(
-    __dirname,
-    "..",
-    "..",
-    "assets",
-    "bundle",
-    "api",
-  );
-}
-
-const BUNDLE_CHANGES: Record<string, [string, string][]> = {
-  "IConnection.ts": [
-    [
-      `export { IConnection } from "@nestia/fetcher"`,
-      `export type { IConnection } from "@nestia/fetcher"`,
-    ],
-  ],
-  "module.ts": [
-    [`export * from "./IConnection"`, `export type * from "./IConnection"`],
-    [`export * from "./Primitive"`, `export type * from "./Primitive"`],
-  ],
-  "Primitive.ts": [
-    [
-      `export { Primitive } from "@nestia/fetcher"`,
-      `export type { Primitive } from "@nestia/fetcher"`,
-    ],
-  ],
-};
+import fs from "fs";
+import NodePath from "path";
+import { IPointer } from "tstl";
+
+import { INestiaProject } from "../structures/INestiaProject";
+import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
+import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
+import { CloneGenerator } from "./CloneGenerator";
+import { SdkDistributionComposer } from "./internal/SdkDistributionComposer";
+import { SdkFileProgrammer } from "./internal/SdkFileProgrammer";
+
+export namespace SdkGenerator {
+  export const generate =
+    (project: INestiaProject) =>
+    async (
+      routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
+    ): Promise<void> => {
+      console.log("Generating SDK Library");
+
+      // PREPARE NEW DIRECTORIES
+      try {
+        await fs.promises.mkdir(project.config.output!);
+      } catch {}
+
+      // BUNDLING
+      const bundle: string[] = await fs.promises.readdir(BUNDLE_PATH);
+      for (const file of bundle) {
+        const current: string = `${BUNDLE_PATH}/${file}`;
+        const target: string = `${project.config.output}/${file}`;
+        const stats: fs.Stats = await fs.promises.stat(current);
+
+        if (stats.isFile() === true) {
+          const content: string = await fs.promises.readFile(current, "utf8");
+          if (fs.existsSync(target) === false)
+            await fs.promises.writeFile(target, content, "utf8");
+          else if (BUNDLE_CHANGES[file] !== undefined) {
+            const r: IPointer<string> = {
+              value: await fs.promises.readFile(target, "utf8"),
+            };
+            for (const [before, after] of BUNDLE_CHANGES[file])
+              r.value = r.value.replace(before, after);
+            await fs.promises.writeFile(target, r.value, "utf8");
+          }
+        }
+      }
+
+      // STRUCTURES
+      if (project.config.clone)
+        await CloneGenerator.write(project)(
+          routes.filter((r) => r.protocol === "http") as ITypedHttpRoute[],
+        );
+
+      // FUNCTIONAL
+      await SdkFileProgrammer.generate(project)(routes);
+
+      // DISTRIBUTION
+      if (project.config.distribute !== undefined)
+        await SdkDistributionComposer.compose(
+          project.config,
+          routes.some((r) => r.protocol === "websocket"),
+        );
+    };
+
+  export const BUNDLE_PATH = NodePath.join(
+    __dirname,
+    "..",
+    "..",
+    "assets",
+    "bundle",
+    "api",
+  );
+}
+
+const BUNDLE_CHANGES: Record<string, [string, string][]> = {
+  "IConnection.ts": [
+    [
+      `export { IConnection } from "@nestia/fetcher"`,
+      `export type { IConnection } from "@nestia/fetcher"`,
+    ],
+  ],
+  "module.ts": [
+    [`export * from "./IConnection"`, `export type * from "./IConnection"`],
+    [`export * from "./Primitive"`, `export type * from "./Primitive"`],
+  ],
+  "Primitive.ts": [
+    [
+      `export { Primitive } from "@nestia/fetcher"`,
+      `export type { Primitive } from "@nestia/fetcher"`,
+    ],
+  ],
+};

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,178 +1,178 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-
-import { INestiaProject } from "../../structures/INestiaProject";
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { FilePrinter } from "./FilePrinter";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkAliasCollection } from "./SdkAliasCollection";
-import { SdkImportWizard } from "./SdkImportWizard";
-import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
-
-export namespace E2eFileProgrammer {
-  export const generate =
-    (project: INestiaProject) =>
-    (props: { api: string; current: string }) =>
-    async (route: ITypedHttpRoute): Promise<void> => {
-      const importer: ImportDictionary = new ImportDictionary(
-        `${props.current}/${getFunctionName(route)}.ts`,
-      );
-      if (project.config.clone !== true)
-        for (const tuple of route.imports)
-          for (const instance of tuple[1])
-            importer.internal({
-              file: tuple[0],
-              type: true,
-              instance,
-            });
-      importer.internal({
-        type: false,
-        file: props.api,
-        instance: null,
-        name: "api",
-      });
-
-      const functor = generate_function(project)(importer)(route);
-      await FilePrinter.write({
-        location: importer.file,
-        statements: [
-          ...importer.toStatements(props.current),
-          FilePrinter.enter(),
-          functor,
-        ],
-      });
-    };
-
-  const generate_function =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.Statement =>
-      ts.factory.createVariableStatement(
-        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              ts.factory.createIdentifier(getFunctionName(route)),
-              undefined,
-              undefined,
-              generate_arrow(project)(importer)(route),
-            ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      );
-
-  const generate_arrow =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute) => {
-      const headers = route.parameters.find(
-        (p) => p.category === "headers" && p.field === undefined,
-      );
-      const connection = headers
-        ? ts.factory.createObjectLiteralExpression(
-            [
-              ts.factory.createSpreadAssignment(
-                ts.factory.createIdentifier("connection"),
-              ),
-              ts.factory.createPropertyAssignment(
-                "headers",
-                ts.factory.createObjectLiteralExpression(
-                  [
-                    ts.factory.createSpreadAssignment(
-                      IdentifierFactory.access(
-                        ts.factory.createIdentifier("connection"),
-                      )("headers"),
-                    ),
-                    ts.factory.createSpreadAssignment(
-                      ts.factory.createCallExpression(
-                        IdentifierFactory.access(
-                          ts.factory.createIdentifier(
-                            SdkImportWizard.typia(importer),
-                          ),
-                        )("random"),
-                        [getTypeName(project)(importer)(headers)],
-                        undefined,
-                      ),
-                    ),
-                  ],
-                  true,
-                ),
-              ),
-            ],
-            true,
-          )
-        : ts.factory.createIdentifier("connection");
-      const caller = ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          ["api", "functional", ...route.accessors].join("."),
-        ),
-        undefined,
-        [
-          connection,
-          ...route.parameters
-            .filter((p) => p.category !== "headers")
-            .map((p) =>
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
-                )("random"),
-                [getTypeName(project)(importer)(p)],
-                undefined,
-              ),
-            ),
-        ],
-      );
-      const assert = ts.factory.createCallExpression(
-        IdentifierFactory.access(
-          ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
-        )("assert"),
-        undefined,
-        [ts.factory.createIdentifier("output")],
-      );
-
-      return ts.factory.createArrowFunction(
-        [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "connection",
-            ts.factory.createTypeReferenceNode("api.IConnection"),
-          ),
-        ],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          ts.factory.createVariableStatement(
-            [],
-            ts.factory.createVariableDeclarationList(
-              [
-                ts.factory.createVariableDeclaration(
-                  "output",
-                  undefined,
-                  project.config.propagate !== true &&
-                    route.output.typeName === "void"
-                    ? undefined
-                    : SdkAliasCollection.output(project)(importer)(route),
-                  ts.factory.createAwaitExpression(caller),
-                ),
-              ],
-              ts.NodeFlags.Const,
-            ),
-          ),
-          ts.factory.createExpressionStatement(assert),
-        ]),
-      );
-    };
-}
-
-const getFunctionName = (route: ITypedHttpRoute): string =>
-  ["test", "api", ...route.accessors].join("_");
-
-const getTypeName =
-  (project: INestiaProject) =>
-  (importer: ImportDictionary) =>
-  (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput) =>
-    p.metadata
-      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
-      : ts.factory.createTypeReferenceNode(p.typeName);
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace E2eFileProgrammer {
+  export const generate =
+    (project: INestiaProject) =>
+    (props: { api: string; current: string }) =>
+    async (route: ITypedHttpRoute): Promise<void> => {
+      const importer: ImportDictionary = new ImportDictionary(
+        `${props.current}/${getFunctionName(route)}.ts`,
+      );
+      if (project.config.clone !== true)
+        for (const tuple of route.imports)
+          for (const instance of tuple[1])
+            importer.internal({
+              file: tuple[0],
+              type: true,
+              instance,
+            });
+      importer.internal({
+        type: false,
+        file: props.api,
+        instance: null,
+        name: "api",
+      });
+
+      const functor = generate_function(project)(importer)(route);
+      await FilePrinter.write({
+        location: importer.file,
+        statements: [
+          ...importer.toStatements(props.current),
+          FilePrinter.enter(),
+          functor,
+        ],
+      });
+    };
+
+  const generate_function =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): ts.Statement =>
+      ts.factory.createVariableStatement(
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createVariableDeclarationList(
+          [
+            ts.factory.createVariableDeclaration(
+              ts.factory.createIdentifier(getFunctionName(route)),
+              undefined,
+              undefined,
+              generate_arrow(project)(importer)(route),
+            ),
+          ],
+          ts.NodeFlags.Const,
+        ),
+      );
+
+  const generate_arrow =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute) => {
+      const headers = route.parameters.find(
+        (p) => p.category === "headers" && p.field === undefined,
+      );
+      const connection = headers
+        ? ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createSpreadAssignment(
+                ts.factory.createIdentifier("connection"),
+              ),
+              ts.factory.createPropertyAssignment(
+                "headers",
+                ts.factory.createObjectLiteralExpression(
+                  [
+                    ts.factory.createSpreadAssignment(
+                      IdentifierFactory.access(
+                        ts.factory.createIdentifier("connection"),
+                      )("headers"),
+                    ),
+                    ts.factory.createSpreadAssignment(
+                      ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                          ts.factory.createIdentifier(
+                            SdkImportWizard.typia(importer),
+                          ),
+                        )("random"),
+                        [getTypeName(project)(importer)(headers)],
+                        undefined,
+                      ),
+                    ),
+                  ],
+                  true,
+                ),
+              ),
+            ],
+            true,
+          )
+        : ts.factory.createIdentifier("connection");
+      const caller = ts.factory.createCallExpression(
+        ts.factory.createIdentifier(
+          ["api", "functional", ...route.accessors].join("."),
+        ),
+        undefined,
+        [
+          connection,
+          ...route.parameters
+            .filter((p) => p.category !== "headers")
+            .map((p) =>
+              ts.factory.createCallExpression(
+                IdentifierFactory.access(
+                  ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+                )("random"),
+                [getTypeName(project)(importer)(p)],
+                undefined,
+              ),
+            ),
+        ],
+      );
+      const assert = ts.factory.createCallExpression(
+        IdentifierFactory.access(
+          ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+        )("assert"),
+        undefined,
+        [ts.factory.createIdentifier("output")],
+      );
+
+      return ts.factory.createArrowFunction(
+        [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "connection",
+            ts.factory.createTypeReferenceNode("api.IConnection"),
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          ts.factory.createVariableStatement(
+            [],
+            ts.factory.createVariableDeclarationList(
+              [
+                ts.factory.createVariableDeclaration(
+                  "output",
+                  undefined,
+                  project.config.propagate !== true &&
+                    route.output.typeName === "void"
+                    ? undefined
+                    : SdkAliasCollection.output(project)(importer)(route),
+                  ts.factory.createAwaitExpression(caller),
+                ),
+              ],
+              ts.NodeFlags.Const,
+            ),
+          ),
+          ts.factory.createExpressionStatement(assert),
+        ]),
+      );
+    };
+}
+
+const getFunctionName = (route: ITypedHttpRoute): string =>
+  ["test", "api", ...route.accessors].join("_");
+
+const getTypeName =
+  (project: INestiaProject) =>
+  (importer: ImportDictionary) =>
+  (p: ITypedHttpRoute.IParameter | ITypedHttpRoute.IOutput) =>
+    p.metadata
+      ? SdkTypeProgrammer.write(project)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/FilePrinter.ts

@@ -1,53 +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;
-    }
-  };
-}
+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;
+    }
+  };
+}