@nestia/sdk 2.0.0-dev.20230991 → 2.0.1

package/src/generates/internal/SdkSimulationProgrammer.ts

@@ -2,27 +2,21 @@ import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
 import { ImportDictionary } from "../../utils/ImportDictionary";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkTypeDefiner } from "./SdkTypeDefiner";
 
 export namespace SdkSimulationProgrammer {
     export const generate =
         (config: INestiaConfig) =>
         (importer: ImportDictionary) =>
         (route: IRoute): string => {
-            const output: boolean = route.output.typeName !== "void";
-            const returns = () => [
-                `return random(`,
-                `    typeof connection.simulate === 'object' &&`,
-                `        connection.simulate !== null`,
-                `        ? connection.simulate`,
-                `        : undefined`,
-                `);`,
-            ];
+            const output: boolean =
+                config.propagate === true || route.output.typeName !== "void";
             const body: string[] = [
                 ...(route.parameters.filter((p) => p.category !== "headers")
                     .length !== 0
-                    ? assert(config)(importer)(route.parameters)
+                    ? assert(config)(importer)(route)
                     : []),
-                ...(output ? returns() : []),
+                ...(output ? returns(config)(route) : []),
             ];
             return [
                 `export const simulate = async (`,
@@ -52,7 +46,7 @@ export namespace SdkSimulationProgrammer {
                                               ? "Query"
                                               : "Input"
                                       }`
-                                    : p.typeName
+                                    : SdkTypeDefiner.name(config)(importer)(p)
                             },`,
                     ),
                 `): Promise<${output ? "Output" : "void"}> => {`,
@@ -66,8 +60,9 @@ export namespace SdkSimulationProgrammer {
     const assert =
         (config: INestiaConfig) =>
         (importer: ImportDictionary) =>
-        (parameters: IRoute.IParameter[]): string[] => {
-            return [
+        (route: IRoute): string[] => {
+            const typia = SdkImportWizard.typia(importer);
+            const func: string[] = [
                 `const assert = ${importer.internal({
                     file: `${config.output}/utils/NestiaSimulator.ts`,
                     instance: "NestiaSimulator",
@@ -75,34 +70,73 @@ export namespace SdkSimulationProgrammer {
                 })}.assert({`,
                 `    method: METADATA.method,`,
                 `    host: connection.host,`,
-                `    path: path(${parameters
+                `    path: path(${route.parameters
                     .filter(
                         (p) => p.category === "param" || p.category === "query",
                     )
                     .map((p) => p.name)
-                    .join(", ")})`,
+                    .join(", ")}),`,
+                `    contentType: ${JSON.stringify(route.output.contentType)},`,
                 `});`,
-                ...parameters
-                    .filter((p) => p.category !== "headers")
-                    .map((p) =>
-                        p.category === "body"
-                            ? `assert.body(() => ${SdkImportWizard.typia(
-                                  importer,
-                              )}.assert(${p.name}));`
-                            : p.category === "query"
-                            ? `assert.query(() => ${SdkImportWizard.typia(
-                                  importer,
-                              )}.assert(${p.name}));`
-                            : p.category === "headers"
-                            ? `assert.headers(() => ${SdkImportWizard.typia(
-                                  importer,
-                              )}.assert(connection.headers);` // not reachable
-                            : `assert.param("${
-                                  p.field
-                              }")(() => ${SdkImportWizard.typia(
-                                  importer,
-                              )}.assert(${p.name}));`,
-                    ),
+            ];
+            const individual: string[] = route.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);`
+                        : `assert.param("${p.field}")(() => ${typia}.assert(${p.name}));`,
+                );
+            if (config.propagate !== true) return [...func, ...individual];
+
+            return [
+                ...func,
+                `try {`,
+                ...individual.map((l) => `    ${l}`),
+                `} catch (exp) {`,
+                `    if (!${typia}.is<${SdkImportWizard.HttpError(
+                    importer,
+                )}>(exp)) throw exp;`,
+                `    return {`,
+                `        success: false,`,
+                `        status: exp.status,`,
+                `        headers: exp.headers,`,
+                `        data: exp.toJSON().message,`,
+                `    } as any;`,
+                `}`,
+            ];
+        };
+
+    const returns =
+        (config: INestiaConfig) =>
+        (route: IRoute): string[] => {
+            const random = (prefix: string, postfix: string) =>
+                route.output.typeName === "void"
+                    ? [`${prefix} undefined${postfix}`]
+                    : [
+                          `${prefix} random(`,
+                          `    typeof connection.simulate === 'object' &&`,
+                          `        connection.simulate !== null`,
+                          `        ? connection.simulate`,
+                          `        : undefined`,
+                          `)${postfix}`,
+                      ];
+            if (config.propagate !== true) return random("return", ";");
+
+            return [
+                `return {`,
+                `    success: true,`,
+                `    status: ${
+                    route.status ?? route.method === "POST" ? 201 : 200
+                },`,
+                `    headers: {`,
+                `        "Content-Type": "${route.output.contentType}",`,
+                `    },`,
+                ...random("data:", ",").map((r) => `    ${r}`),
+                `}`,
             ];
         };
 }

package/src/generates/internal/SdkTypeDefiner.ts

@@ -0,0 +1,120 @@
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkDtoGenerator } from "./SdkDtoGenerator";
+
+export namespace SdkTypeDefiner {
+    export const name =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (p: IRoute.IParameter | IRoute.IOutput): string =>
+            p.metadata
+                ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
+                : p.typeName;
+
+    export const headers =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (param: IRoute.IParameter): string => {
+            const type: string = name(config)(importer)(param);
+            if (config.primitive === false) return type;
+
+            const resolved: string = importer.external({
+                type: true,
+                library: "@nestia/fetcher",
+                instance: "Resolved",
+            });
+            return `${resolved}<${type}>`;
+        };
+
+    export const query =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (param: IRoute.IParameter): string => {
+            const type: string = name(config)(importer)(param);
+            if (config.primitive === false) return type;
+
+            const resolved: string = importer.external({
+                type: true,
+                library: "@nestia/fetcher",
+                instance: "Resolved",
+            });
+            return `${resolved}<${type}>`;
+        };
+
+    export const input =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (param: IRoute.IParameter): string => {
+            const type: string = name(config)(importer)(param);
+            if (config.primitive === false) return type;
+
+            const primitive: string = importer.external({
+                type: true,
+                library: "@nestia/fetcher",
+                instance: "Primitive",
+            });
+            return `${primitive}<${type}>`;
+        };
+
+    export const output =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (route: IRoute): string => {
+            if (config.propagate !== true) {
+                const type: string = name(config)(importer)(route.output);
+                if (type === "void" || config.primitive === false) return type;
+
+                const primitive: string = importer.external({
+                    type: true,
+                    library: "@nestia/fetcher",
+                    instance: "Primitive",
+                });
+                return `${primitive}<${type}>`;
+            }
+
+            const propagation: string = importer.external({
+                type: true,
+                library: "@nestia/fetcher",
+                instance: "IPropagation",
+            });
+            const branches: IBranch[] = [
+                {
+                    status: String(
+                        route.status ?? route.method === "POST" ? 201 : 200,
+                    ),
+                    type: name(config)(importer)(route.output),
+                },
+                ...Object.entries(route.exceptions).map(([status, value]) => ({
+                    status,
+                    type: name(config)(importer)(value),
+                })),
+            ];
+            return (
+                `${propagation}<{\n` +
+                branches
+                    .map(
+                        (b) =>
+                            `        ${
+                                b.status.endsWith("XX")
+                                    ? `"${b.status}"`
+                                    : b.status
+                            }: ${b.type};`,
+                    )
+                    .join("\n") +
+                "\n" +
+                `    }${route.status ? `, ${route.status}` : ""}>`
+            );
+        };
+
+    export const responseBody =
+        (config: INestiaConfig) =>
+        (importer: ImportDictionary) =>
+        (route: IRoute): string =>
+            output({ ...config, propagate: false })(importer)(route);
+}
+
+interface IBranch {
+    status: string;
+    type: string;
+}

package/src/generates/internal/SwaggerSchemaGenerator.ts

@@ -49,7 +49,7 @@ export namespace SwaggerSchemaGenerator {
                         ...result.errors.map((e) => ({
                             ...e,
                             route,
-                            from: `response body (status: ${status})`,
+                            from: `response(status: ${status})`,
                         })),
                     );
 
@@ -57,14 +57,14 @@ export namespace SwaggerSchemaGenerator {
                     description: exp.description ?? "",
                     content: {
                         "application/json": {
-                            schema: coalesceSchema(props)(result),
+                            schema: coalesce(props)(result),
                         },
                     },
                 };
             }
 
             // FROM COMMENT TAGS -> ANY
-            for (const tag of route.tags) {
+            for (const tag of route.jsDocTags) {
                 if (tag.name !== "throw" && tag.name !== "throws") continue;
 
                 const text: string | undefined = tag.text?.find(
@@ -133,7 +133,7 @@ export namespace SwaggerSchemaGenerator {
                     ...result.errors.map((e) => ({
                         ...e,
                         route,
-                        from: `response body (status: ${status})`,
+                        from: "response",
                     })),
                 );
 
@@ -151,7 +151,7 @@ export namespace SwaggerSchemaGenerator {
                         ? undefined
                         : {
                               [route.output.contentType]: {
-                                  schema: coalesceSchema(props)(result),
+                                  schema: coalesce(props)(result),
                               },
                           },
                 "x-nestia-encrypted": route.encrypted,
@@ -180,7 +180,7 @@ export namespace SwaggerSchemaGenerator {
                     ...result.errors.map((e) => ({
                         ...e,
                         route,
-                        from: `body parameter ${param.name}`,
+                        from: param.name,
                     })),
                 );
 
@@ -198,7 +198,7 @@ export namespace SwaggerSchemaGenerator {
             );
 
             // RETURNS WITH LAZY CONSTRUCTION
-            const schema: IJsonSchema = coalesceSchema(props)(result);
+            const schema: IJsonSchema = coalesce(props)(result);
             return {
                 description: encrypted
                     ? `${warning.get(!!description).get("request")}${
@@ -218,49 +218,13 @@ export namespace SwaggerSchemaGenerator {
     export const parameter =
         (props: IProps) =>
         (route: IRoute) =>
-        (param: IRoute.IParameter): ISwaggerRoute.IParameter =>
+        (param: IRoute.IParameter): ISwaggerRoute.IParameter[] =>
             param.category === "headers"
                 ? headers(props)(route)(param)
                 : param.category === "param"
-                ? path(props)(route)(param)
+                ? [path(props)(route)(param)]
                 : query(props)(route)(param);
 
-    const headers =
-        (props: IProps) =>
-        (route: IRoute) =>
-        (param: IRoute.IParameter): ISwaggerRoute.IParameter => {
-            // ANALYZE TYPE WITH VALIDATIONS
-            const result = (() => {
-                const result = MetadataFactory.analyze(props.checker)({
-                    escape: false,
-                    constant: true,
-                    absorb: true,
-                })(props.collection)(param.type);
-                if (result.success === false)
-                    props.errors.push(
-                        ...result.errors.map((e) => ({
-                            ...e,
-                            route,
-                            from: `header parameter ${param.name}`,
-                        })),
-                    );
-                else if (result.data.objects.length === 1) {
-                    // WHEN OBJECT CASE, VALIDATE IT MORE DETAILY
-                    const again = MetadataFactory.analyze(props.checker)({
-                        escape: false,
-                        constant: true,
-                        absorb: true,
-                        validate: SwaggerSchemaValidator.headers,
-                    })(new MetadataCollection())(param.type);
-                    if (again.success === false) return again;
-                }
-                return result;
-            })();
-
-            // RETURNS WITH LAZY CONSTRUCTION
-            return lazyParameterReturns(props)(route)("header")(param, result);
-        };
-
     const path =
         (props: IProps) =>
         (route: IRoute) =>
@@ -277,86 +241,124 @@ export namespace SwaggerSchemaGenerator {
                     ...result.errors.map((e) => ({
                         ...e,
                         route,
-                        from: `path parameter ${param.name}`,
+                        from: param.name,
                     })),
                 );
 
             // RETURNS WITH LAZY CONSTRUCTION
-            return lazyParameterReturns(props)(route)("path")(param, result);
+            return lazy(props)(route)(param, result);
         };
 
-    const query =
+    const headers =
         (props: IProps) =>
         (route: IRoute) =>
-        (param: IRoute.IParameter): ISwaggerRoute.IParameter => {
-            // ANALYZE TYPE WITH VALIDATIONS
-            const result = (() => {
-                const result = MetadataFactory.analyze(props.checker)({
+        (param: IRoute.IParameter): ISwaggerRoute.IParameter[] =>
+            decomposible(props)(route)(param)(
+                MetadataFactory.analyze(props.checker)({
                     escape: false,
                     constant: true,
                     absorb: true,
-                })(props.collection)(param.type);
-                if (result.success === false) {
-                    props.errors.push(
-                        ...result.errors.map((e) => ({
-                            ...e,
-                            route,
-                            from: `query parameter ${param.name}`,
-                        })),
-                    );
-                } else if (result.data.objects.length === 1) {
-                    // WHEN OBJECT CASE, VALIDATE IT MORE DETAILY
-                    const again = MetadataFactory.analyze(props.checker)({
-                        escape: false,
-                        constant: true,
-                        absorb: true,
-                        validate: SwaggerSchemaValidator.query,
-                    })(new MetadataCollection())(param.type);
-                    if (again.success === false) return again;
-                }
-                return result;
-            })();
+                    validate: param.custom
+                        ? SwaggerSchemaValidator.headers
+                        : undefined,
+                })(new MetadataCollection())(param.type),
+            );
 
-            // RETURNS WITH LAZY CONSTRUCTION
-            return lazyParameterReturns(props)(route)("query")(param, result);
-        };
+    const query =
+        (props: IProps) =>
+        (route: IRoute) =>
+        (param: IRoute.IParameter): ISwaggerRoute.IParameter[] =>
+            decomposible(props)(route)(param)(
+                MetadataFactory.analyze(props.checker)({
+                    escape: false,
+                    constant: true,
+                    absorb: true,
+                    validate: param.custom
+                        ? SwaggerSchemaValidator.query
+                        : undefined,
+                })(new MetadataCollection())(param.type),
+            );
 
-    const coalesceSchema =
+    const decomposible =
         (props: IProps) =>
+        (route: IRoute) =>
+        (param: IRoute.IParameter) =>
         (
             result: ValidationPipe<Metadata, MetadataFactory.IError>,
-        ): IJsonSchema => {
-            const schema: IJsonSchema = {} as any;
-            props.tuples.push({
-                metadata: result.success ? result.data : any.get(),
-                schema,
+        ): ISwaggerRoute.IParameter[] => {
+            if (result.success === false) {
+                props.errors.push(
+                    ...result.errors.map((e) => ({
+                        ...e,
+                        route,
+                        from: param.name,
+                    })),
+                );
+                return [lazy(props)(route)(param, result)];
+            } else if (
+                props.config.decompose !== true ||
+                result.data.objects.length === 0
+            )
+                return [lazy(props)(route)(param, result)];
+
+            return result.data.objects[0].properties.map((p) => {
+                const schema = coalesce(props)({
+                    success: true,
+                    data: p.value,
+                });
+                return {
+                    name: p.key.constants[0].values[0] as string,
+                    in:
+                        param.category === "headers"
+                            ? "header"
+                            : param.category,
+                    schema,
+                    description: p.description ?? undefined,
+                    required: p.value.isRequired(),
+                };
             });
-            return schema;
         };
 
-    const lazyParameterReturns =
+    const lazy =
         (props: IProps) =>
         (route: IRoute) =>
-        (inKeyword: string) =>
         (
             param: IRoute.IParameter,
             result: ValidationPipe<Metadata, MetadataFactory.IError>,
-        ) => {
-            const schema: IJsonSchema = coalesceSchema(props)(result);
+        ): ISwaggerRoute.IParameter => {
+            const schema: IJsonSchema = coalesce(props)(result);
             return {
                 name: param.field ?? param.name,
-                in: inKeyword,
+                in:
+                    param.category === "headers"
+                        ? "header"
+                        : param.category === "param"
+                        ? "path"
+                        : param.category,
                 schema,
                 description: describe(route, "param", param.name) ?? "",
                 required: result.success ? result.data.isRequired() : true,
             };
         };
 
-    function describe(
+    const coalesce =
+        (props: IProps) =>
+        (
+            result: ValidationPipe<Metadata, MetadataFactory.IError>,
+        ): IJsonSchema => {
+            const schema: IJsonSchema = {} as any;
+            props.tuples.push({
+                metadata: result.success ? result.data : any.get(),
+                schema,
+            });
+            return schema;
+        };
+
+    const describe = (
         route: IRoute,
         tagName: string,
         parameterName?: string,
-    ): string | undefined {
+    ): string | undefined => {
         const parametric: (elem: ts.JSDocTagInfo) => boolean = parameterName
             ? (tag) =>
                   tag.text!.find(
@@ -366,13 +368,13 @@ export namespace SwaggerSchemaGenerator {
                   ) !== undefined
             : () => true;
 
-        const tag: ts.JSDocTagInfo | undefined = route.tags.find(
+        const tag: ts.JSDocTagInfo | undefined = route.jsDocTags.find(
             (tag) => tag.name === tagName && tag.text && parametric(tag),
         );
         return tag && tag.text
             ? tag.text.find((elem) => elem.kind === "text")?.text
             : undefined;
-    }
+    };
 }
 
 const warning = new Singleton((described: boolean) => {

package/src/generates/internal/SwaggerSchemaValidator.ts

@@ -64,12 +64,6 @@ export namespace SwaggerSchemaValidator {
             // PROPERTY MUST BE SOLE
             if (typeof explore.property === "object")
                 insert("dynamic property is not allowed.");
-            // MUST BE LOWER-CASE
-            if (
-                typeof explore.property === "string" &&
-                explore.property !== explore.property.toLowerCase()
-            )
-                insert("property name must be lower-case.");
             // DO NOT ALLOW TUPLE TYPE
             if (meta.tuples.length) insert("tuple type is not allowed.");
             // DO NOT ALLOW UNION TYPE
@@ -136,12 +130,6 @@ export namespace SwaggerSchemaValidator {
             // PROPERTY MUST BE SOLE
             if (typeof explore.property === "object")
                 insert("dynamic property is not allowed.");
-            // MUST BE LOWER-CASE
-            if (
-                typeof explore.property === "string" &&
-                explore.property !== explore.property.toLowerCase()
-            )
-                insert("property name must be lower-case.");
             // DO NOT ALLOW TUPLE TYPE
             if (meta.tuples.length) insert("tuple type is not allowed.");
             // DO NOT ALLOW UNION TYPE

package/src/structures/IController.ts

@@ -6,6 +6,7 @@ export interface IController {
     paths: string[];
     functions: IController.IFunction[];
     security: Record<string, string[]>[];
+    swaggerTgas: string[];
 }
 
 export namespace IController {
@@ -23,6 +24,7 @@ export namespace IController {
             number | "2XX" | "3XX" | "4XX" | "5XX",
             IController.IException
         >;
+        swaggerTags: string[];
     }
 
     export type IParameter =

package/src/structures/IRoute.ts

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
 import { IController } from "./IController";
 
 export interface IRoute {
@@ -15,16 +17,20 @@ export interface IRoute {
     output: IRoute.IOutput;
 
     location: string;
-    symbol: string;
+    symbol: {
+        class: string;
+        function: string;
+    };
     description?: string;
     operationId?: string;
-    tags: ts.JSDocTagInfo[];
+    jsDocTags: ts.JSDocTagInfo[];
     setHeaders: Array<
         | { type: "setter"; source: string; target?: string }
         | { type: "assigner"; source: string }
     >;
     security: Record<string, string[]>[];
     exceptions: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>;
+    swaggerTags: string[];
 }
 
 export namespace IRoute {
@@ -32,10 +38,12 @@ export namespace IRoute {
         optional: boolean;
         type: ts.Type;
         typeName: string;
+        metadata?: Metadata;
     };
     export interface IOutput {
         type: ts.Type;
         typeName: string;
+        metadata?: Metadata;
         description?: string;
         contentType: "application/json" | "text/plain";
     }