@nestia/sdk 2.0.0-dev.20230991 → 2.0.0

package/src/generates/internal/SdkDtoGenerator.ts

@@ -0,0 +1,384 @@
+import fs from "fs";
+import ts from "typescript";
+
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { IJsDocTagInfo } from "typia/lib/schemas/metadata/IJsDocTagInfo";
+import { IMetadataTypeTag } from "typia/lib/schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataAlias } from "typia/lib/schemas/metadata/MetadataAlias";
+import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
+import { MetadataAtomic } from "typia/lib/schemas/metadata/MetadataAtomic";
+import { MetadataConstant } from "typia/lib/schemas/metadata/MetadataConstant";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { MetadataProperty } from "typia/lib/schemas/metadata/MetadataProperty";
+import { MetadataTuple } from "typia/lib/schemas/metadata/MetadataTuple";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { MapUtil } from "../../utils/MapUtil";
+
+export namespace SdkDtoGenerator {
+    export const generate =
+        (checker: ts.TypeChecker) =>
+        (config: INestiaConfig) =>
+        async (routes: IRoute[]): Promise<void> => {
+            try {
+                await fs.promises.mkdir(`${config.output}/structures`);
+            } catch {}
+
+            const collection = new MetadataCollection({
+                replace: MetadataCollection.replace,
+            });
+            for (const r of routes) {
+                for (const p of r.parameters) {
+                    const res = MetadataFactory.analyze(checker)({
+                        escape: false,
+                        constant: true,
+                        absorb: false,
+                    })(collection)(p.type);
+                    if (res.success) p.metadata = res.data;
+                }
+                const res = MetadataFactory.analyze(checker)({
+                    escape: true,
+                    constant: true,
+                    absorb: false,
+                })(collection)(r.output.type);
+                if (res.success) r.output.metadata = res.data;
+            }
+
+            const modules: Map<string, IModule> = new Map();
+            for (const alias of collection.aliases())
+                prepare(modules)(alias.name)((importer) =>
+                    defineAlias(config)(importer)(alias),
+                );
+            for (const object of collection.objects())
+                prepare(modules)(object.name)((importer) =>
+                    defineObject(config)(importer)(object),
+                );
+
+            for (const module of modules.values())
+                await generateFile(config)(module);
+        };
+
+    const prepare =
+        (dict: Map<string, IModule>) =>
+        (name: string) =>
+        (programmer: (importer: ImportDictionary) => string) => {
+            const accessors: string[] = name.split(".");
+            let module: IModule;
+
+            accessors.forEach((acc, i) => {
+                module = MapUtil.take(dict, acc, () => ({
+                    name: accessors.slice(0, i + 1).join("."),
+                    children: new Map(),
+                }));
+                module.programmer = programmer;
+                dict = module.children;
+            });
+            return module!;
+        };
+
+    const generateFile =
+        (config: INestiaConfig) =>
+        async (module: IModule): Promise<void> => {
+            const importer: ImportDictionary = new ImportDictionary();
+
+            const body: string = writeModule(importer)(module);
+            const content: string[] = [];
+            if (!importer.empty())
+                content.push(
+                    importer.toScript(`${config.output}/structures`),
+                    "",
+                );
+            content.push(body);
+
+            const location: string = `${config.output}/structures/${module.name}.ts`;
+            await fs.promises.writeFile(location, content.join("\n"), "utf8");
+        };
+
+    const writeModule =
+        (importer: ImportDictionary) =>
+        (module: IModule): string => {
+            const content: string[] = [];
+            if (module.programmer) content.push(module.programmer(importer));
+            if (module.children.size) {
+                content.push(
+                    `export namespace ${module.name.split(".").at(-1)} {`,
+                );
+                for (const child of module.children.values())
+                    content.push(
+                        writeModule(importer)(child)
+                            .split("\n")
+                            .map((l) => `    ${l}`)
+                            .join("\n"),
+                    );
+                content.push("}");
+            }
+            return content.join("\n");
+        };
+
+    const defineAlias =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (alias: MetadataAlias) =>
+            [
+                ...writeComment(alias.description, alias.jsDocTags),
+                `export type ${alias.name.split(".").pop()!} = ${decode(config)(
+                    importer,
+                )(alias.value)};`,
+            ].join("\n");
+
+    const defineObject =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (object: MetadataObject) => {
+            const top: string = [
+                ...writeComment(object.description ?? null, object.jsDocTags),
+                `export type ${object.name.split(".").pop()!} = `,
+            ].join("\n");
+            if (object.properties.length === 0) return top + "{};";
+
+            const regular: MetadataProperty[] = object.properties.filter((p) =>
+                p.key.isSoleLiteral(),
+            );
+            const dynamic: MetadataProperty[] = object.properties.filter(
+                (p) => !p.key.isSoleLiteral(),
+            );
+
+            const brackets: string[][] = [];
+            if (regular.length) {
+                const row: string[] = ["{"];
+                for (const p of regular) {
+                    const key: string = p.key.constants[0].values[0] as string;
+                    const identifier: string = Escaper.variable(key)
+                        ? key
+                        : JSON.stringify(key);
+                    row.push(
+                        ...writeComment(p.description, p.jsDocTags).map(
+                            (l) => `    ${l}`,
+                        ),
+                        `    ${identifier}: ${decode(config)(importer)(
+                            p.value,
+                        )};`,
+                    );
+                }
+                row.push("}");
+                brackets.push(row);
+            }
+            for (const p of dynamic) {
+                const row: string[] = ["{"];
+                row.push(
+                    ...writeComment(p.description, p.jsDocTags).map(
+                        (l) => `    ${l}`,
+                    ),
+                    `    [key: ${decode(config)(importer)(p.key)}]: ${decode(
+                        config,
+                    )(importer)(p.value)};`,
+                );
+                row.push("}");
+                brackets.push(row);
+            }
+            return top + brackets.map((row) => row.join("\n")).join(" & ");
+        };
+
+    const writeComment = (
+        description: string | null,
+        jsDocTags: IJsDocTagInfo[],
+    ): string[] => {
+        const lines: string[] = [];
+        if (description?.length)
+            lines.push(...description.split("\n").map((s) => `${s}`));
+        if (description?.length && jsDocTags?.length) lines.push("");
+        if (jsDocTags?.length)
+            lines.push(
+                ...jsDocTags.map((t) =>
+                    t.text?.length
+                        ? `@${t.name} ${t.text.map((e) => e.text).join("")}`
+                        : `@${t.name}`,
+                ),
+            );
+        if (lines.length === 0) return [];
+        return ["/**", ...lines.map((s) => ` * ${s}`), " */"];
+    };
+
+    export const decode =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (meta: Metadata): string => {
+            const union: string[] = [];
+
+            // COALESCES
+            if (meta.nullable) union.push("null");
+            if (meta.required === false) union.push("undefined");
+
+            // ATOMICS
+            for (const atomic of meta.atomics)
+                union.push(decodeAtomic(importer)(atomic));
+            for (const constant of meta.constants)
+                union.push(decodeConstant(constant));
+            for (const tpl of meta.templates)
+                union.push(decodeTemplate(config)(importer)(tpl));
+
+            // ARRAYS
+            for (const array of meta.arrays)
+                union.push(decodeArray(config)(importer)(array));
+            for (const tuple of meta.tuples)
+                union.push(decodeTuple(config)(importer)(tuple));
+
+            // OBJECTS
+            for (const obj of meta.objects)
+                union.push(decodeObject(config)(importer)(obj));
+            for (const alias of meta.aliases)
+                union.push(decodeAlias(config)(importer)(alias));
+
+            return union.join(" | ");
+        };
+
+    const decodeTypeTag =
+        (importer: ImportDictionary) =>
+        (tag: IMetadataTypeTag): string => {
+            const front: string = tag.name.split("<")[0];
+            if (NATIVE_TYPE_TAGS.has(front)) {
+                importer.external({
+                    type: true,
+                    library: `typia/lib/tags/${front}`,
+                    instance: front,
+                });
+                return tag.name;
+            }
+            importer.external({
+                type: true,
+                library: `typia/lib/tags/TagBase`,
+                instance: "TagBase",
+            });
+            return `TagBase<${JSON.stringify(tag)}>`;
+        };
+
+    const decodeTypeTagMatrix =
+        (importer: ImportDictionary) =>
+        (base: string, tags: IMetadataTypeTag[][]): string => {
+            if (tags.length === 0) return base;
+            else if (tags.length === 1)
+                return `(${base} & ${tags[0]
+                    .map((t) => decodeTypeTag(importer)(t))
+                    .join(" & ")})`;
+            return (
+                "(" +
+                [
+                    base,
+                    ...tags.map(
+                        (row) =>
+                            `(${row
+                                .map((t) => decodeTypeTag(importer)(t))
+                                .join(" & ")})`,
+                    ),
+                ] +
+                ")"
+            );
+        };
+
+    const decodeAtomic =
+        (importer: ImportDictionary) =>
+        (atomic: MetadataAtomic): string =>
+            decodeTypeTagMatrix(importer)(atomic.type, atomic.tags);
+
+    const decodeTemplate =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (template: Metadata[]): string =>
+            "`" +
+            template
+                .map((meta) =>
+                    meta.size() === 1 &&
+                    meta.isRequired() &&
+                    meta.nullable === false &&
+                    meta.constants.length === 1
+                        ? String(meta.constants[0].values[0])
+                              .split("`")
+                              .join("\\`")
+                        : `\${${decode(config)(importer)(meta)}}`,
+                )
+                .join("") +
+            "`";
+
+    const decodeConstant = (constant: MetadataConstant): string => {
+        if (constant.values.length === 0)
+            return JSON.stringify(constant.values[0]);
+        return `(${constant.values
+            .map((val) => JSON.stringify(val))
+            .join(" | ")})`;
+    };
+
+    const decodeArray =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (array: MetadataArray): string =>
+            decodeTypeTagMatrix(importer)(
+                `Array<${decode(config)(importer)(array.type.value)}>`,
+                array.tags,
+            );
+
+    const decodeTuple =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (tuple: MetadataTuple): string =>
+            "[" +
+            tuple.type.elements.map((e) =>
+                e.rest
+                    ? `...${decode(config)(importer)(e.rest)}`
+                    : decode(config)(importer)(e),
+            ) +
+            "]";
+
+    const decodeAlias =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (alias: MetadataAlias) => {
+            importInternalFile(config)(importer)(alias.name);
+            return alias.name;
+        };
+
+    const decodeObject =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (object: MetadataObject) => {
+            importInternalFile(config)(importer)(object.name);
+            return object.name;
+        };
+
+    const importInternalFile =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (name: string) => {
+            const top = name.split(".")[0];
+            importer.internal({
+                type: true,
+                file: `${config.output}/structures/${name.split(".")[0]}`,
+                instance: top,
+            });
+        };
+}
+
+const NATIVE_TYPE_TAGS = new Set([
+    "ExclusiveMinimum",
+    "ExclusiveMaximum",
+    "Format",
+    "Maximum",
+    "MaxItems",
+    "MaxLength",
+    "Minimum",
+    "MinItems",
+    "MinLength",
+    "MultipleOf",
+    "Pattern",
+    "Type",
+]);
+
+interface IModule {
+    name: string;
+    children: Map<string, IModule>;
+    programmer?: (importer: ImportDictionary) => string;
+}

package/src/generates/internal/SdkFileProgrammer.ts

@@ -73,13 +73,14 @@ export namespace SdkFileProgrammer {
                     type: false,
                 });
             directory.routes.forEach((route, i) => {
-                for (const tuple of route.imports)
-                    for (const instance of tuple[1])
-                        importer.internal({
-                            file: tuple[0],
-                            instance,
-                            type: true,
-                        });
+                if (config.clone !== true)
+                    for (const tuple of route.imports)
+                        for (const instance of tuple[1])
+                            importer.internal({
+                                file: tuple[0],
+                                instance,
+                                type: true,
+                            });
 
                 content.push(
                     SdkFunctionProgrammer.generate(config)(importer)(route),

package/src/generates/internal/SdkFunctionProgrammer.ts

@@ -7,8 +7,10 @@ import { INestiaConfig } from "../../INestiaConfig";
 import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
 import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkDtoGenerator } from "./SdkDtoGenerator";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkSimulationProgrammer } from "./SdkSimulationProgrammer";
+import { SdkTypeDefiner } from "./SdkTypeDefiner";
 
 export namespace SdkFunctionProgrammer {
     export const generate =
@@ -132,7 +134,9 @@ export namespace SdkFunctionProgrammer {
                     [
                         `${awa ? "await " : ""}${SdkImportWizard.Fetcher(
                             encrypted,
-                        )(importer)}.fetch(`,
+                        )(importer)}.${
+                            config.propagate === true ? "propagate" : "fetch"
+                        }(`,
                         fetchArguments
                             .map((param) =>
                                 typeof param === "string"
@@ -163,23 +167,28 @@ export namespace SdkFunctionProgrammer {
                 `    // configure header(s)\n`,
                 `    connection.headers ??= {};\n`,
             ];
-
-            for (const header of route.setHeaders) {
-                if (header.type === "assigner")
-                    content.push(
-                        "    ",
-                        `Object.assign(connection.headers, ${access("output")(
-                            header.source,
-                        )});\n`,
-                    );
-                else
-                    content.push(
-                        "    ",
-                        `${access("connection.headers")(
-                            header.target ?? header.source,
-                        )} = ${access("output")(header.source)};\n`,
-                    );
-            }
+            const headerContents = (variable: string) =>
+                route.setHeaders.map((header) =>
+                    header.type === "assigner"
+                        ? `Object.assign(connection.headers, ${access(variable)(
+                              header.source,
+                          )});`
+                        : `${access("connection.headers")(
+                              header.target ?? header.source,
+                          )} = ${access(variable)(header.source)};`,
+                );
+            if (config.propagate === true) {
+                content.push(`    if (output.success) {\n`);
+                content.push(
+                    ...headerContents("output.data").map(
+                        (line) => `        ${line}\n`,
+                    ),
+                );
+                content.push(`    }\n`);
+            } else
+                content.push(
+                    ...headerContents("output").map((line) => `    ${line}\n`),
+                );
             content.push("\n", "    return output;\n", "}");
             return content.join("");
         };
@@ -221,7 +230,7 @@ export namespace SdkFunctionProgrammer {
                 : [];
 
             // COMMENT TAGS
-            const tags: IJsDocTagInfo[] = route.tags.filter(
+            const tags: IJsDocTagInfo[] = route.jsDocTags.filter(
                 (tag) =>
                     tag.name !== "param" ||
                     route.parameters
@@ -283,7 +292,7 @@ export namespace SdkFunctionProgrammer {
                                 ? `${route.name}.${
                                       param === props.query ? "Query" : "Input"
                                   }`
-                                : param.typeName;
+                                : getTypeName(config)(importer)(param);
                         return `${param.name}${
                             param.optional ? "?" : ""
                         }: ${type}`;
@@ -292,7 +301,7 @@ export namespace SdkFunctionProgrammer {
 
             // OUTPUT TYPE
             const output: string =
-                route.output.typeName === "void"
+                config.propagate !== true && route.output.typeName === "void"
                     ? "void"
                     : `${route.name}.Output`;
 
@@ -321,13 +330,33 @@ export namespace SdkFunctionProgrammer {
             // LIST UP TYPES
             const types: Pair<string, string>[] = [];
             if (props.headers !== undefined)
-                types.push(new Pair("Headers", props.headers.typeName));
+                types.push(
+                    new Pair(
+                        "Headers",
+                        SdkTypeDefiner.headers(config)(importer)(props.headers),
+                    ),
+                );
             if (props.query !== undefined)
-                types.push(new Pair("Query", props.query.typeName));
+                types.push(
+                    new Pair(
+                        "Query",
+                        SdkTypeDefiner.query(config)(importer)(props.query),
+                    ),
+                );
             if (props.input !== undefined)
-                types.push(new Pair("Input", props.input.typeName));
-            if (route.output.typeName !== "void")
-                types.push(new Pair("Output", route.output.typeName));
+                types.push(
+                    new Pair(
+                        "Input",
+                        SdkTypeDefiner.input(config)(importer)(props.input),
+                    ),
+                );
+            if (config.propagate === true || route.output.typeName !== "void")
+                types.push(
+                    new Pair(
+                        "Output",
+                        SdkTypeDefiner.output(config)(importer)(route),
+                    ),
+                );
 
             // PATH WITH PARAMETERS
             const parameters: IRoute.IParameter[] = filter_path_parameters(
@@ -344,13 +373,7 @@ export namespace SdkFunctionProgrammer {
                     ? types
                           .map(
                               (tuple) =>
-                                  `    export type ${tuple.first} = ${
-                                      config.primitive !== false
-                                          ? `${SdkImportWizard.Primitive(
-                                                importer,
-                                            )}<${tuple.second}>`
-                                          : tuple.second
-                                  };`,
+                                  `    export type ${tuple.first} = ${tuple.second};`,
                           )
                           .join("\n") + "\n"
                     : "") +
@@ -401,7 +424,7 @@ export namespace SdkFunctionProgrammer {
                                 param.category === "query" &&
                                 param.typeName === props.query?.typeName
                                     ? `${route.name}.Query`
-                                    : param.typeName
+                                    : getTypeName(config)(importer)(param)
                             }`,
                     )
                     .join(", ")}): string => {\n` +
@@ -410,10 +433,14 @@ export namespace SdkFunctionProgrammer {
                 (config.simulate === true && route.output.typeName !== "void"
                     ? `    export const random = (g?: Partial<${SdkImportWizard.typia(
                           importer,
-                      )}.IRandomGenerator>): Output =>\n` +
+                      )}.IRandomGenerator>): ${SdkTypeDefiner.responseBody(
+                          config,
+                      )(importer)(route)} =>\n` +
                       `        ${SdkImportWizard.typia(
                           importer,
-                      )}.random<Output>(g);\n`
+                      )}.random<${SdkTypeDefiner.responseBody(config)(importer)(
+                          route,
+                      )}>(g);\n`
                     : "") +
                 (config.simulate === true
                     ? SdkSimulationProgrammer.generate(config)(importer)(
@@ -425,7 +452,7 @@ export namespace SdkFunctionProgrammer {
                     undefined
                     ? `    export const stringify = (input: Input) => ${SdkImportWizard.typia(
                           importer,
-                      )}.assertStringify(input);\n`
+                      )}.json.assertStringify(input);\n`
                     : "") +
                 "}"
             );
@@ -507,3 +534,10 @@ export namespace SdkFunctionProgrammer {
 }
 
 const space = (count: number) => " ".repeat(count);
+const getTypeName =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (p: IRoute.IParameter | IRoute.IOutput) =>
+        p.metadata
+            ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
+            : p.typeName;

package/src/generates/internal/SdkImportWizard.ts

@@ -4,6 +4,13 @@ export namespace SdkImportWizard {
     export const Fetcher = (encrypted: boolean) =>
         encrypted ? EncryptedFetcher : PlainFetcher;
 
+    export const HttpError = (importer: ImportDictionary) =>
+        importer.external({
+            type: true,
+            library: "@nestia/fetcher",
+            instance: "HttpError",
+        });
+
     export const IConnection = (importer: ImportDictionary) =>
         importer.external({
             type: true,
@@ -18,6 +25,13 @@ export namespace SdkImportWizard {
             instance: "Primitive",
         });
 
+    export const Resolved = (importer: ImportDictionary) =>
+        importer.external({
+            type: true,
+            library: "@nestia/fetcher",
+            instance: "Resolved",
+        });
+
     export const typia = (importer: ImportDictionary) =>
         importer.external({
             type: false,