@nestia/sdk 1.6.7 → 2.0.0-dev.20230830

package/src/generates/internal/SdkSimulationProgrammer.ts

@@ -1,79 +1,113 @@
+import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
 
 export namespace SdkSimulationProgrammer {
-    export const generate = (route: IRoute): string => {
-        const output: boolean = route.output.name !== "void";
-        const returns = () => [
-            `return random(`,
-            `    typeof connection.simulate === 'object' &&`,
-            `        connection.simulate !== null`,
-            `        ? connection.simulate`,
-            `        : undefined`,
-            `);`,
-        ];
-        const body: string[] = [
-            ...(route.parameters.filter((p) => p.category !== "headers")
-                .length !== 0
-                ? assert(route.parameters)
-                : []),
-            ...(output ? returns() : []),
-        ];
+    export const generate =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (route: IRoute): string => {
+            const output: boolean = route.output.name !== "void";
+            const returns = () => [
+                `return random(`,
+                `    typeof connection.simulate === 'object' &&`,
+                `        connection.simulate !== null`,
+                `        ? connection.simulate`,
+                `        : undefined`,
+                `);`,
+            ];
+            const body: string[] = [
+                ...(route.parameters.filter((p) => p.category !== "headers")
+                    .length !== 0
+                    ? assert(config)(importer)(route.parameters)
+                    : []),
+                ...(output ? returns() : []),
+            ];
+            const connectionType: string = importer.external({
+                type: true,
+                library: "@nestia/fetcher",
+                instance: "IConnection",
+            });
 
-        return [
-            `export const simulate = async (`,
-            `    ${
-                route.parameters.filter((p) => p.category !== "headers")
-                    .length === 0 && route.output.name === "void"
-                    ? "_connection"
-                    : "connection"
-            }: ${
-                route.parameters.some(
-                    (p) => p.category === "headers" && p.field === undefined,
-                )
-                    ? `IConnection<${route.name}.Headers>`
-                    : `IConnection`
-            },`,
-            ...route.parameters
-                .filter((p) => p.category !== "headers")
-                .map(
-                    (p) =>
-                        `    ${p.name}: ${
-                            p.category === "query" || p.category === "body"
-                                ? `${route.name}.${
-                                      p.category === "query" ? "Query" : "Input"
-                                  }`
-                                : p.type.name
-                        },`,
-                ),
-            `): Promise<${output ? "Output" : "void"}> => {`,
-            ...body.map((l) => `    ${l}`),
-            `}`,
-        ]
-            .map((line) => `    ${line}`)
-            .join("\n");
-    };
+            return [
+                `export const simulate = async (`,
+                `    ${
+                    route.parameters.filter((p) => p.category !== "headers")
+                        .length === 0 && route.output.name === "void"
+                        ? "_connection"
+                        : "connection"
+                }: ${
+                    route.parameters.some(
+                        (p) =>
+                            p.category === "headers" && p.field === undefined,
+                    )
+                        ? `${connectionType}<${route.name}.Headers>`
+                        : connectionType
+                },`,
+                ...route.parameters
+                    .filter((p) => p.category !== "headers")
+                    .map(
+                        (p) =>
+                            `    ${p.name}: ${
+                                p.category === "query" || p.category === "body"
+                                    ? `${route.name}.${
+                                          p.category === "query"
+                                              ? "Query"
+                                              : "Input"
+                                      }`
+                                    : p.type.name
+                            },`,
+                    ),
+                `): Promise<${output ? "Output" : "void"}> => {`,
+                ...body.map((l) => `    ${l}`),
+                `}`,
+            ]
+                .map((line) => `    ${line}`)
+                .join("\n");
+        };
 
-    const assert = (parameters: IRoute.IParameter[]): string[] => [
-        `const assert = NestiaSimulator.assert({`,
-        `    method: METHOD,`,
-        `    host: connection.host,`,
-        `    path: path(${parameters
-            .filter((p) => p.category === "param" || p.category === "query")
-            .map((p) => p.name)
-            .join(", ")})`,
-        `});`,
-        ...parameters
-            .filter((p) => p.category !== "headers")
-            .map((p) =>
-                p.category === "body"
-                    ? `assert.body(() => typia.assert(${p.name}));`
-                    : p.category === "query"
-                    ? `assert.query(() => typia.assert(${p.name}));`
-                    : p.category === "headers"
-                    ? `assert.headers(() => typia.assert(connection.headers);` // not reachable
-                    : `assert.param("${p.field}")("${
-                          p.custom && p.meta ? p.meta.type : p.type.name
-                      }")(() => typia.assert(${p.name}));`,
-            ),
-    ];
+    const assert =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (parameters: IRoute.IParameter[]): string[] => {
+            const typiaType = () =>
+                importer.external({
+                    type: false,
+                    library: "typia",
+                    instance: null,
+                });
+            return [
+                `const assert = ${importer.internal({
+                    file: `${config.output}/utils/NestiaSimulator.ts`,
+                    instance: "NestiaSimulator",
+                    type: false,
+                })}.assert({`,
+                `    method: METADATA.method,`,
+                `    host: connection.host,`,
+                `    path: path(${parameters
+                    .filter(
+                        (p) => p.category === "param" || p.category === "query",
+                    )
+                    .map((p) => p.name)
+                    .join(", ")})`,
+                `});`,
+                ...parameters
+                    .filter((p) => p.category !== "headers")
+                    .map((p) =>
+                        p.category === "body"
+                            ? `assert.body(() => ${typiaType()}.assert(${
+                                  p.name
+                              }));`
+                            : p.category === "query"
+                            ? `assert.query(() => ${typiaType()}.assert(${
+                                  p.name
+                              }));`
+                            : p.category === "headers"
+                            ? `assert.headers(() => ${typiaType()}.assert(connection.headers);` // not reachable
+                            : `assert.param("${p.field}")("${
+                                  p.custom && p.meta ? p.meta.type : p.type.name
+                              }")(() => ${typiaType()}.assert(${p.name}));`,
+                    ),
+            ];
+        };
 }

package/src/utils/ImportDictionary.ts

@@ -4,53 +4,117 @@ import { HashSet } from "tstl/container/HashSet";
 import { Pair } from "tstl/utility/Pair";
 
 export class ImportDictionary {
-    private readonly dict_: HashMap<string, Pair<boolean, HashSet<string>>> =
+    private readonly externals_: HashMap<Pair<string, boolean>, IComposition> =
+        new HashMap();
+    private readonly internals_: HashMap<Pair<string, boolean>, IComposition> =
         new HashMap();
 
     public empty(): boolean {
-        return this.dict_.empty();
+        return this.internals_.empty() && this.externals_.empty();
+    }
+
+    public external(props: ImportDictionary.IExternalProps): string {
+        const composition: IComposition = this.externals_.take(
+            new Pair(props.library, props.type),
+            () => ({
+                location: 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 emplace(file: string, realistic: boolean, instance: string): void {
-        if (file.substr(-5) === ".d.ts") file = file.substr(0, file.length - 5);
-        else if (file.substr(-3) === ".ts")
-            file = file.substr(0, file.length - 3);
-        else
+    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(0, props.file.length - 3) === ".ts")
+                return props.file.substring(0, props.file.length - 3);
             throw new Error(
-                `Error on ImportDictionary.emplace(): extension of the target file "${file}" is not "ts".`,
+                `Error on ImportDictionary.emplace(): extension of the target file "${props.file}" is not "ts".`,
             );
-
-        const pair: Pair<boolean, HashSet<string>> = this.dict_.take(
-            file,
-            () => new Pair(realistic, new HashSet()),
+        })();
+        const composition: IComposition = this.internals_.take(
+            new Pair(file, props.type),
+            () => ({
+                location: file,
+                elements: new HashSet(),
+                default: false,
+                type: props.type,
+            }),
         );
-        pair.second.insert(instance);
+        if (props.instance === null) composition.default = true;
+        else composition.elements.insert(props.instance);
+        return props.instance ?? file;
     }
 
     public toScript(outDir: string): string {
         const statements: string[] = [];
-        for (const it of this.dict_) {
-            const file: string = (() => {
-                const location: string = path
-                    .relative(outDir, it.first)
-                    .split("\\")
-                    .join("/");
-                const index: number = location.lastIndexOf(NODE_MODULES);
-                return index === -1
-                    ? `./${location}`
-                    : location.substring(index + NODE_MODULES.length);
-            })();
-            const realistic: boolean = it.second.first;
-            const instances: string[] = it.second.second.toJSON();
-
-            statements.push(
-                `import ${!realistic ? "type " : ""}{ ${instances.join(
-                    ", ",
-                )} } from "${file}";`,
-            );
-        }
+        const enroll =
+            (locator: (str: string) => string) =>
+            (dict: HashMap<Pair<string, boolean>, IComposition>) => {
+                const compositions: IComposition[] = dict
+                    .toJSON()
+                    .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.location);
+                    if (c.elements.empty() === false)
+                        brackets.push(
+                            `{${c.elements
+                                .toJSON()
+                                .sort((a, b) => a.localeCompare(b))
+                                .join(", ")}`,
+                        );
+                    statements.push(
+                        `import ${c.type ? "type " : ""} ${brackets.join(
+                            ", ",
+                        )} from "${c.location}";`,
+                    );
+                }
+            };
+
+        enroll((str) => str)(this.externals_);
+        if (this.internals_.size()) statements.push("");
+        enroll((str) => {
+            const location: string = path
+                .relative(outDir, str)
+                .split("\\")
+                .join("/");
+            const index: number = location.lastIndexOf(NODE_MODULES);
+            return index === -1
+                ? `./${location}`
+                : location.substring(index + NODE_MODULES.length);
+        })(this.internals_);
         return statements.join("\n");
     }
 }
+export namespace ImportDictionary {
+    export interface IInternalProps {
+        type: boolean;
+        file: string;
+        instance: string;
+    }
+    export interface IExternalProps {
+        type: boolean;
+        library: string;
+        instance: string | null;
+    }
+}
+
+interface IComposition {
+    location: string;
+    type: boolean;
+    default: boolean;
+    elements: HashSet<string>;
+}
 
 const NODE_MODULES = "node_modules/";