@nestia/core 2.1.8 → 2.2.0-dev.20231010

package/src/programmers/http/HttpValidateQuerifyProgrammer.ts

@@ -0,0 +1,64 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpValidateQuerifyProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "query",
+                        HttpQuerifyProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("query"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            ts.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/transformers/ParameterDecoratorTransformer.ts

@@ -6,6 +6,7 @@ import { PlainBodyProgrammer } from "../programmers/PlainBodyProgrammer";
 import { TypedBodyProgrammer } from "../programmers/TypedBodyProgrammer";
 import { TypedHeadersProgrammer } from "../programmers/TypedHeadersProgrammer";
 import { TypedParamProgrammer } from "../programmers/TypedParamProgrammer";
+import { TypedQueryBodyProgrammer } from "../programmers/TypedQueryBodyProgrammer";
 import { TypedQueryProgrammer } from "../programmers/TypedQueryProgrammer";
 
 export namespace ParameterDecoratorTransformer {
@@ -39,7 +40,9 @@ export namespace ParameterDecoratorTransformer {
             // FIND PROGRAMMER
             const programmer: Programmer | undefined =
                 FUNCTORS[
-                    project.checker.getTypeAtLocation(declaration).symbol.name
+                    getName(
+                        project.checker.getTypeAtLocation(declaration).symbol,
+                    )
                 ];
             if (programmer === undefined) return decorator;
 
@@ -88,6 +91,10 @@ const FUNCTORS: Record<string, Programmer> = {
         parameters.length
             ? parameters
             : [TypedQueryProgrammer.generate(project)(modulo)(type)],
+    "TypedQuery.Body": (project) => (modulo) => (parameters) => (type) =>
+        parameters.length
+            ? parameters
+            : [TypedQueryBodyProgrammer.generate(project)(modulo)(type)],
     PlainBody: (project) => (modulo) => (parameters) => (type) =>
         parameters.length
             ? parameters
@@ -102,3 +109,18 @@ const LIB_PATH = path.join(
     "decorators",
 );
 const SRC_PATH = path.resolve(path.join(__dirname, "..", "decorators"));
+
+const getName = (symbol: ts.Symbol): string => {
+    const parent = symbol.getDeclarations()?.[0]?.parent;
+    return parent
+        ? exploreName(parent)(symbol.escapedName.toString())
+        : "__type";
+};
+const exploreName =
+    (decl: ts.Node) =>
+    (name: string): string =>
+        ts.isModuleBlock(decl)
+            ? exploreName(decl.parent.parent)(
+                  `${decl.parent.name.getFullText().trim()}.${name}`,
+              )
+            : name;

package/src/transformers/TypedRouteTransformer.ts

@@ -2,6 +2,7 @@ import path from "path";
 import ts from "typescript";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { TypedQueryRouteProgrammer } from "../programmers/TypedQueryRouteProgrammer";
 import { TypedRouteProgrammer } from "../programmers/TypedRouteProgrammer";
 
 export namespace TypedRouteTransformer {
@@ -17,7 +18,7 @@ export namespace TypedRouteTransformer {
             if (!signature || !signature.declaration) return decorator;
 
             // CHECK TO BE TRANSFORMED
-            const done: boolean = (() => {
+            const modulo = (() => {
                 // CHECK FILENAME
                 const location: string = path.resolve(
                     signature.declaration.getSourceFile().fileName,
@@ -26,7 +27,7 @@ export namespace TypedRouteTransformer {
                     LIB_PATHS.every((str) => location.indexOf(str) === -1) &&
                     SRC_PATHS.every((str) => location !== str)
                 )
-                    return false;
+                    return null;
 
                 // CHECK DUPLICATE BOOSTER
                 if (decorator.expression.arguments.length >= 2) return false;
@@ -39,9 +40,12 @@ export namespace TypedRouteTransformer {
                         project.checker.getTypeAtLocation(last);
                     if (isObject(project.checker)(type)) return false;
                 }
-                return true;
+                return location.split(path.sep).at(-1)?.split(".")[0] ===
+                    "TypedQuery"
+                    ? "TypedQuery"
+                    : "TypedRoute";
             })();
-            if (done === false) return decorator;
+            if (modulo === null) return decorator;
 
             // CHECK TYPE NODE
             const typeNode: ts.TypeNode | undefined =
@@ -56,9 +60,12 @@ export namespace TypedRouteTransformer {
                     decorator.expression.typeArguments,
                     [
                         ...decorator.expression.arguments,
-                        TypedRouteProgrammer.generate(project)(
-                            decorator.expression.expression,
-                        )(type),
+                        (modulo === "TypedQuery"
+                            ? TypedQueryRouteProgrammer
+                            : TypedRouteProgrammer
+                        ).generate(project)(decorator.expression.expression)(
+                            type,
+                        ),
                     ],
                 ),
             );
@@ -72,7 +79,7 @@ export namespace TypedRouteTransformer {
             !(checker as any).isArrayType(type) &&
             !(checker as any).isArrayLikeType(type);
 
-    const CLASSES = ["EncryptedRoute", "TypedRoute"];
+    const CLASSES = ["EncryptedRoute", "TypedRoute", "TypedQuery"];
     const LIB_PATHS = CLASSES.map((cla) =>
         path.join(
             "node_modules",