@nestia/sdk 2.0.0-dev.20230904 → 2.0.0-dev.20230906

package/src/generates/internal/SwaggerSchemaGenerator.ts

@@ -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(
@@ -151,7 +151,7 @@ export namespace SwaggerSchemaGenerator {
                         ? undefined
                         : {
                               [route.output.contentType]: {
-                                  schema: coalesceSchema(props)(result),
+                                  schema: coalesce(props)(result),
                               },
                           },
                 "x-nestia-encrypted": route.encrypted,
@@ -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: 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) =>
@@ -282,81 +246,114 @@ export namespace SwaggerSchemaGenerator {
                 );
 
             // 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: 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,
                 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 +363,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

@@ -130,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 {
@@ -18,16 +20,17 @@ export interface IRoute {
     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 {
@@ -35,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";
     }