@nestia/core 2.5.4-dev.20240204 → 2.5.5-dev.20240213

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/core",
-  "version": "2.5.4-dev.20240204",
+  "version": "2.5.5-dev.20240213",
   "description": "Super-fast validation decorators of NestJS",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -36,7 +36,7 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@nestia/fetcher": "^2.5.4-dev.20240204",
+    "@nestia/fetcher": "^2.5.5-dev.20240213",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "@nestjs/platform-express": ">=7.0.1",
@@ -50,7 +50,7 @@
     "typia": "^5.4.5"
   },
   "peerDependencies": {
-    "@nestia/fetcher": ">=2.5.4-dev.20240204",
+    "@nestia/fetcher": ">=2.5.5-dev.20240213",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "@nestjs/platform-express": ">=7.0.1",

package/src/module.ts

@@ -1,15 +1,15 @@
-export * from "./decorators/DynamicModule";
-export * from "./decorators/EncryptedBody";
-export * from "./decorators/EncryptedController";
-export * from "./decorators/EncryptedModule";
-export * from "./decorators/EncryptedRoute";
-export * from "./utils/ExceptionManager";
-export * from "./decorators/PlainBody";
-export * from "./decorators/TypedBody";
-export * from "./decorators/TypedException";
-export * from "./decorators/TypedHeaders";
-export * from "./decorators/TypedFormData";
-export * from "./decorators/TypedParam";
-export * from "./decorators/TypedRoute";
-export * from "./decorators/TypedQuery";
-export * from "./options/INestiaTransformOptions";
+export * from "./decorators/DynamicModule";
+export * from "./decorators/EncryptedBody";
+export * from "./decorators/EncryptedController";
+export * from "./decorators/EncryptedModule";
+export * from "./decorators/EncryptedRoute";
+export * from "./utils/ExceptionManager";
+export * from "./decorators/PlainBody";
+export * from "./decorators/TypedBody";
+export * from "./decorators/TypedException";
+export * from "./decorators/TypedHeaders";
+export * from "./decorators/TypedFormData";
+export * from "./decorators/TypedParam";
+export * from "./decorators/TypedRoute";
+export * from "./decorators/TypedQuery";
+export * from "./options/INestiaTransformOptions";

package/src/programmers/PlainBodyProgrammer.ts

@@ -1,52 +1,52 @@
-import ts from "typescript";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-
-export namespace PlainBodyProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      const result = MetadataFactory.analyze(project.checker)({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate,
-      })(new MetadataCollection())(type);
-      if (result.success === false)
-        throw TransformerError.from("nestia.core.TypedParam")(result.errors);
-      return AssertProgrammer.write({
-        ...project,
-        options: {
-          numeric: false,
-          finite: false,
-          functional: false,
-        },
-      })(modulo)(false)(type);
-    };
-}
-
-const validate = (metadata: Metadata): string[] => {
-  const errors: string[] = [];
-  const insert = (msg: string) => errors.push(msg);
-
-  const expected: number =
-    (metadata.atomics.some((a) => a.type === "string") ? 1 : 0) +
-    metadata.templates.length +
-    metadata.constants
-      .filter((c) => c.type === "string")
-      .map((c) => c.values.length)
-      .reduce((a, b) => a + b, 0);
-  if (expected === 0 || expected !== metadata.size())
-    insert(`only string type is allowed`);
-  if (metadata.isRequired() === false) insert(`do not allow undefindable type`);
-  if (metadata.nullable === true) insert(`do not allow nullable type`);
-  else if (metadata.any === true) insert(`do not allow any type`);
-
-  return errors;
-};
+import ts from "typescript";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace PlainBodyProgrammer {
+  export const generate =
+    (project: INestiaTransformProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.Expression => {
+      const result = MetadataFactory.analyze(project.checker)({
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      })(new MetadataCollection())(type);
+      if (result.success === false)
+        throw TransformerError.from("nestia.core.TypedParam")(result.errors);
+      return AssertProgrammer.write({
+        ...project,
+        options: {
+          numeric: false,
+          finite: false,
+          functional: false,
+        },
+      })(modulo)(false)(type);
+    };
+}
+
+const validate = (metadata: Metadata): string[] => {
+  const errors: string[] = [];
+  const insert = (msg: string) => errors.push(msg);
+
+  const expected: number =
+    (metadata.atomics.some((a) => a.type === "string") ? 1 : 0) +
+    metadata.templates.length +
+    metadata.constants
+      .filter((c) => c.type === "string")
+      .map((c) => c.values.length)
+      .reduce((a, b) => a + b, 0);
+  if (expected === 0 || expected !== metadata.size())
+    insert(`only string type is allowed`);
+  if (metadata.isRequired() === false) insert(`do not allow undefindable type`);
+  if (metadata.nullable === true) insert(`do not allow nullable type`);
+  else if (metadata.any === true) insert(`do not allow any type`);
+
+  return errors;
+};

package/src/programmers/TypedExceptionProgrammer.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
-import { TypeFactory } from "typia/lib/factories/TypeFactory";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-
-export namespace TypedExceptionProgrammer {
-  export const generate =
-    ({ checker }: INestiaTransformProject) =>
-    (expression: ts.CallExpression): ts.CallExpression => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments?.[0])
-        throw TransformerError.from("nestia.core.TypedException")([
-          {
-            name: "uknown",
-            messages: [NOT_SPECIFIED],
-            explore: {
-              top: true,
-              object: null,
-              property: null,
-              nested: null,
-              escaped: false,
-              aliased: false,
-            },
-          },
-        ]);
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = checker.getTypeFromTypeNode(node);
-
-      // VALIDATE TYPE
-      if (type.isTypeParameter())
-        throw TransformerError.from("nestia.core.TypedException")([
-          {
-            name: TypeFactory.getFullName(checker)(type),
-            messages: [NO_GENERIC_ARGUMENT],
-            explore: {
-              top: true,
-              object: null,
-              property: null,
-              nested: null,
-              escaped: false,
-              aliased: false,
-            },
-          },
-        ]);
-      JsonMetadataFactory.analyze("@nestia.core.TypedException")(checker)(type);
-
-      // CHECK DUPLICATED TRNASFORMATION
-      if (expression.arguments.length === 3) return expression;
-
-      // DO TRANSFORM
-      const name: string = TypeFactory.getFullName(checker)(type);
-      return ts.factory.updateCallExpression(
-        expression,
-        expression.expression,
-        expression.typeArguments,
-        [
-          expression.arguments[0],
-          expression.arguments[1] ?? ts.factory.createIdentifier("undefined"),
-          ts.factory.createStringLiteral(name),
-        ],
-      );
-    };
-}
-
-const NOT_SPECIFIED =
-  "Error on @nestia.core.TypedException(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-  "Error on @nestia.core.TypedException(): non-specified generic argument.";
+import ts from "typescript";
+import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace TypedExceptionProgrammer {
+  export const generate =
+    ({ checker }: INestiaTransformProject) =>
+    (expression: ts.CallExpression): ts.CallExpression => {
+      // CHECK GENERIC ARGUMENT EXISTENCE
+      if (!expression.typeArguments?.[0])
+        throw TransformerError.from("nestia.core.TypedException")([
+          {
+            name: "uknown",
+            messages: [NOT_SPECIFIED],
+            explore: {
+              top: true,
+              object: null,
+              property: null,
+              nested: null,
+              escaped: false,
+              aliased: false,
+            },
+          },
+        ]);
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = expression.typeArguments[0];
+      const type: ts.Type = checker.getTypeFromTypeNode(node);
+
+      // VALIDATE TYPE
+      if (type.isTypeParameter())
+        throw TransformerError.from("nestia.core.TypedException")([
+          {
+            name: TypeFactory.getFullName(checker)(type),
+            messages: [NO_GENERIC_ARGUMENT],
+            explore: {
+              top: true,
+              object: null,
+              property: null,
+              nested: null,
+              escaped: false,
+              aliased: false,
+            },
+          },
+        ]);
+      JsonMetadataFactory.analyze("@nestia.core.TypedException")(checker)(type);
+
+      // CHECK DUPLICATED TRNASFORMATION
+      if (expression.arguments.length === 3) return expression;
+
+      // DO TRANSFORM
+      const name: string = TypeFactory.getFullName(checker)(type);
+      return ts.factory.updateCallExpression(
+        expression,
+        expression.expression,
+        expression.typeArguments,
+        [
+          expression.arguments[0],
+          expression.arguments[1] ?? ts.factory.createIdentifier("undefined"),
+          ts.factory.createStringLiteral(name),
+        ],
+      );
+    };
+}
+
+const NOT_SPECIFIED =
+  "Error on @nestia.core.TypedException(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+  "Error on @nestia.core.TypedException(): non-specified generic argument.";

package/src/programmers/http/HttpQuerifyProgrammer.ts

@@ -1,96 +1,96 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
-import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
-import { IProject } from "typia/lib/transformers/IProject";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-export namespace HttpQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ArrowFunction => {
-      // GET OBJECT TYPE
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const collection: MetadataCollection = new MetadataCollection();
-      const result = MetadataFactory.analyze(project.checker)({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: HttpQueryProgrammer.validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(
-          `nestia.core.TypedQuery.${importer.method}`,
-        )(result.errors);
-
-      const object: MetadataObject = result.data.objects[0]!;
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...importer.declare(modulo),
-            StatementFactory.constant(
-              "output",
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier("URLSearchParams"),
-                undefined,
-                [],
-              ),
-            ),
-            ...object.properties.map((p) =>
-              ts.factory.createExpressionStatement(
-                decode(p.key.constants[0]!.values[0] as string)(p.value),
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("output"),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  const decode =
-    (key: string) =>
-    (value: Metadata): ts.CallExpression =>
-      !!value.arrays.length
-        ? ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              IdentifierFactory.access(ts.factory.createIdentifier("input"))(
-                key,
-              ),
-            )("forEach"),
-            undefined,
-            [
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("elem")],
-                undefined,
-                undefined,
-                append(key)(ts.factory.createIdentifier("elem")),
-              ),
-            ],
-          )
-        : append(key)(
-            IdentifierFactory.access(ts.factory.createIdentifier("input"))(key),
-          );
-
-  const append = (key: string) => (elem: ts.Expression) =>
-    ts.factory.createCallExpression(
-      IdentifierFactory.access(ts.factory.createIdentifier("output"))("append"),
-      undefined,
-      [ts.factory.createStringLiteral(key), elem],
-    );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
+import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { IProject } from "typia/lib/transformers/IProject";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+export namespace HttpQuerifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.ArrowFunction => {
+      // GET OBJECT TYPE
+      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
+      const collection: MetadataCollection = new MetadataCollection();
+      const result = MetadataFactory.analyze(project.checker)({
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: HttpQueryProgrammer.validate,
+      })(collection)(type);
+      if (result.success === false)
+        throw TransformerError.from(
+          `nestia.core.TypedQuery.${importer.method}`,
+        )(result.errors);
+
+      const object: MetadataObject = result.data.objects[0]!;
+      return ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input")],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...importer.declare(modulo),
+            StatementFactory.constant(
+              "output",
+              ts.factory.createNewExpression(
+                ts.factory.createIdentifier("URLSearchParams"),
+                undefined,
+                [],
+              ),
+            ),
+            ...object.properties.map((p) =>
+              ts.factory.createExpressionStatement(
+                decode(p.key.constants[0]!.values[0] as string)(p.value),
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createIdentifier("output"),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  const decode =
+    (key: string) =>
+    (value: Metadata): ts.CallExpression =>
+      !!value.arrays.length
+        ? ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              IdentifierFactory.access(ts.factory.createIdentifier("input"))(
+                key,
+              ),
+            )("forEach"),
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("elem")],
+                undefined,
+                undefined,
+                append(key)(ts.factory.createIdentifier("elem")),
+              ),
+            ],
+          )
+        : append(key)(
+            IdentifierFactory.access(ts.factory.createIdentifier("input"))(key),
+          );
+
+  const append = (key: string) => (elem: ts.Expression) =>
+    ts.factory.createCallExpression(
+      IdentifierFactory.access(ts.factory.createIdentifier("output"))("append"),
+      undefined,
+      [ts.factory.createStringLiteral(key), elem],
+    );
+}

package/src/transformers/ParameterDecoratorTransformer.ts

@@ -1,126 +1,126 @@
-import path from "path";
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { PlainBodyProgrammer } from "../programmers/PlainBodyProgrammer";
-import { TypedBodyProgrammer } from "../programmers/TypedBodyProgrammer";
-import { TypedFormDataBodyProgrammer } from "../programmers/TypedFormDataBodyProgrammer";
-import { TypedHeadersProgrammer } from "../programmers/TypedHeadersProgrammer";
-import { TypedParamProgrammer } from "../programmers/TypedParamProgrammer";
-import { TypedQueryBodyProgrammer } from "../programmers/TypedQueryBodyProgrammer";
-import { TypedQueryProgrammer } from "../programmers/TypedQueryProgrammer";
-
-export namespace ParameterDecoratorTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (type: ts.Type) =>
-    (decorator: ts.Decorator): ts.Decorator => {
-      //----
-      // VALIDATIONS
-      //----
-      // CHECK DECORATOR
-      if (!ts.isCallExpression(decorator.expression)) return decorator;
-
-      // SIGNATURE DECLARATION
-      const declaration: ts.Declaration | undefined =
-        project.checker.getResolvedSignature(decorator.expression)?.declaration;
-      if (declaration === undefined) return decorator;
-
-      // FILE PATH
-      const file: string = path.resolve(declaration.getSourceFile().fileName);
-      if (file.indexOf(LIB_PATH) === -1 && file.indexOf(SRC_PATH) === -1)
-        return decorator;
-
-      //----
-      // TRANSFORMATION
-      //----
-      // FIND PROGRAMMER
-      const programmer: Programmer | undefined =
-        FUNCTORS[
-          getName(project.checker.getTypeAtLocation(declaration).symbol)
-        ];
-      if (programmer === undefined) return decorator;
-
-      // GET TYPE INFO
-      const typeNode: ts.TypeNode | undefined = project.checker.typeToTypeNode(
-        type,
-        undefined,
-        undefined,
-      );
-      if (typeNode === undefined) return decorator;
-
-      // DO TRANSFORM
-      return ts.factory.createDecorator(
-        ts.factory.updateCallExpression(
-          decorator.expression,
-          decorator.expression.expression,
-          decorator.expression.typeArguments,
-          programmer(project)(decorator.expression.expression)(
-            decorator.expression.arguments,
-          )(type),
-        ),
-      );
-    };
-}
-
-type Programmer = (
-  project: INestiaTransformProject,
-) => (
-  modulo: ts.LeftHandSideExpression,
-) => (
-  parameters: readonly ts.Expression[],
-) => (type: ts.Type) => readonly ts.Expression[];
-
-const FUNCTORS: Record<string, Programmer> = {
-  EncryptedBody: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
-  TypedBody: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
-  TypedHeaders: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedHeadersProgrammer.generate(project)(modulo)(type)],
-  TypedParam: (project) => TypedParamProgrammer.generate(project),
-  TypedQuery: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedQueryProgrammer.generate(project)(modulo)(type)],
-  "TypedQuery.Body": (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedQueryBodyProgrammer.generate(project)(modulo)(type)],
-  "TypedFormData.Body": (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedFormDataBodyProgrammer.generate(project)(modulo)(type)],
-  PlainBody: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [PlainBodyProgrammer.generate(project)(modulo)(type)],
-};
-
-const LIB_PATH = path.join(
-  "node_modules",
-  "@nestia",
-  "core",
-  "lib",
-  "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;
+import path from "path";
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { PlainBodyProgrammer } from "../programmers/PlainBodyProgrammer";
+import { TypedBodyProgrammer } from "../programmers/TypedBodyProgrammer";
+import { TypedFormDataBodyProgrammer } from "../programmers/TypedFormDataBodyProgrammer";
+import { TypedHeadersProgrammer } from "../programmers/TypedHeadersProgrammer";
+import { TypedParamProgrammer } from "../programmers/TypedParamProgrammer";
+import { TypedQueryBodyProgrammer } from "../programmers/TypedQueryBodyProgrammer";
+import { TypedQueryProgrammer } from "../programmers/TypedQueryProgrammer";
+
+export namespace ParameterDecoratorTransformer {
+  export const transform =
+    (project: INestiaTransformProject) =>
+    (type: ts.Type) =>
+    (decorator: ts.Decorator): ts.Decorator => {
+      //----
+      // VALIDATIONS
+      //----
+      // CHECK DECORATOR
+      if (!ts.isCallExpression(decorator.expression)) return decorator;
+
+      // SIGNATURE DECLARATION
+      const declaration: ts.Declaration | undefined =
+        project.checker.getResolvedSignature(decorator.expression)?.declaration;
+      if (declaration === undefined) return decorator;
+
+      // FILE PATH
+      const file: string = path.resolve(declaration.getSourceFile().fileName);
+      if (file.indexOf(LIB_PATH) === -1 && file.indexOf(SRC_PATH) === -1)
+        return decorator;
+
+      //----
+      // TRANSFORMATION
+      //----
+      // FIND PROGRAMMER
+      const programmer: Programmer | undefined =
+        FUNCTORS[
+          getName(project.checker.getTypeAtLocation(declaration).symbol)
+        ];
+      if (programmer === undefined) return decorator;
+
+      // GET TYPE INFO
+      const typeNode: ts.TypeNode | undefined = project.checker.typeToTypeNode(
+        type,
+        undefined,
+        undefined,
+      );
+      if (typeNode === undefined) return decorator;
+
+      // DO TRANSFORM
+      return ts.factory.createDecorator(
+        ts.factory.updateCallExpression(
+          decorator.expression,
+          decorator.expression.expression,
+          decorator.expression.typeArguments,
+          programmer(project)(decorator.expression.expression)(
+            decorator.expression.arguments,
+          )(type),
+        ),
+      );
+    };
+}
+
+type Programmer = (
+  project: INestiaTransformProject,
+) => (
+  modulo: ts.LeftHandSideExpression,
+) => (
+  parameters: readonly ts.Expression[],
+) => (type: ts.Type) => readonly ts.Expression[];
+
+const FUNCTORS: Record<string, Programmer> = {
+  EncryptedBody: (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
+  TypedBody: (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
+  TypedHeaders: (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [TypedHeadersProgrammer.generate(project)(modulo)(type)],
+  TypedParam: (project) => TypedParamProgrammer.generate(project),
+  TypedQuery: (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [TypedQueryProgrammer.generate(project)(modulo)(type)],
+  "TypedQuery.Body": (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [TypedQueryBodyProgrammer.generate(project)(modulo)(type)],
+  "TypedFormData.Body": (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [TypedFormDataBodyProgrammer.generate(project)(modulo)(type)],
+  PlainBody: (project) => (modulo) => (parameters) => (type) =>
+    parameters.length
+      ? parameters
+      : [PlainBodyProgrammer.generate(project)(modulo)(type)],
+};
+
+const LIB_PATH = path.join(
+  "node_modules",
+  "@nestia",
+  "core",
+  "lib",
+  "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;