@nestia/core 3.17.0 → 4.0.0-dev.20241010-2

package/src/programmers/TypedBodyProgrammer.ts

@@ -7,102 +7,126 @@ import { MiscAssertCloneProgrammer } from "typia/lib/programmers/misc/MiscAssert
 import { MiscAssertPruneProgrammer } from "typia/lib/programmers/misc/MiscAssertPruneProgrammer";
 import { MiscValidateCloneProgrammer } from "typia/lib/programmers/misc/MiscValidateCloneProgrammer";
 import { MiscValidatePruneProgrammer } from "typia/lib/programmers/misc/MiscValidatePruneProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
 
 export namespace TypedBodyProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ObjectLiteralExpression => {
-      // VALIDATE TYPE
-      JsonMetadataFactory.analyze("@nestia.core.TypedBody")(project.checker)(
-        type,
-      );
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ObjectLiteralExpression => {
+    // VALIDATE TYPE
+    JsonMetadataFactory.analyze({
+      method: "@nestia.core.TypedBody",
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      type: props.type,
+    });
 
-      // GENERATE VALIDATION PLAN
-      const check =
-        (key: IRequestBodyValidator<any>["type"]) =>
-        (equals: boolean) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-          ) => (equals: boolean) => (type: ts.Type) => ts.Expression,
-        ) =>
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("type"),
-              ts.factory.createStringLiteral(key),
-            ),
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier(key),
-              programmer({
-                ...project,
+    // GENERATE VALIDATION PLAN
+    const check =
+      (key: IRequestBodyValidator<any>["type"]) =>
+      (equals: boolean) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          config: {
+            equals: boolean;
+            guard: boolean;
+          };
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier("type"),
+            ts.factory.createStringLiteral(key),
+          ),
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier(key),
+            programmer({
+              context: {
+                ...props.context,
                 options: {
                   numeric: false,
                   finite: false,
                   functional: false,
                 },
-              })(modulo)(equals)(type),
-            ),
-          ]);
-      const misc =
-        (key: IRequestBodyValidator<any>["type"]) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-          ) => (type: ts.Type) => ts.Expression,
-        ) =>
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("type"),
-              ts.factory.createStringLiteral(key),
-            ),
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier(key),
-              programmer({
-                ...project,
+              },
+              modulo: props.modulo,
+              config: {
+                equals,
+                guard: false,
+              },
+              type: props.type,
+              name: undefined,
+            }),
+          ),
+        ]);
+    const misc =
+      (key: IRequestBodyValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier("type"),
+            ts.factory.createStringLiteral(key),
+          ),
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier(key),
+            programmer({
+              context: {
+                ...props.context,
                 options: {
                   numeric: false,
                   finite: false,
                   functional: false,
                 },
-              })(modulo)(type),
-            ),
-          ]);
+              },
+              modulo: props.modulo,
+              type: props.type,
+              name: undefined,
+            }),
+          ),
+        ]);
 
-      //----
-      // RETURNS
-      //----
-      const category = project.options.validate;
-      // NORMAL
-      if (category === "is") return check("is")(false)(IsProgrammer.write);
-      else if (category === "validate")
-        return check("validate")(false)(ValidateProgrammer.write);
-      // STRICT
-      else if (category === "validateEquals")
-        return check("validate")(true)(ValidateProgrammer.write);
-      else if (category === "equals")
-        return check("is")(true)(IsProgrammer.write);
-      else if (category === "assertEquals")
-        return check("assert")(true)(AssertProgrammer.write);
-      // CLONE
-      else if (category === "assertClone")
-        return misc("assert")(MiscAssertCloneProgrammer.write);
-      else if (category === "validateClone")
-        return misc("validate")(MiscValidateCloneProgrammer.write);
-      // PRUNE
-      else if (category === "assertPrune")
-        return misc("assert")(MiscAssertPruneProgrammer.write);
-      else if (category === "validatePrune")
-        return misc("validate")(MiscValidatePruneProgrammer.write);
-      // DEFAULT
-      return check("assert")(false)(AssertProgrammer.write);
-    };
+    //----
+    // RETURNS
+    //----
+    const category = props.context.options.validate;
+    // NORMAL
+    if (category === "is") return check("is")(false)(IsProgrammer.write);
+    else if (category === "validate")
+      return check("validate")(false)(ValidateProgrammer.write);
+    // STRICT
+    else if (category === "validateEquals")
+      return check("validate")(true)(ValidateProgrammer.write);
+    else if (category === "equals")
+      return check("is")(true)(IsProgrammer.write);
+    else if (category === "assertEquals")
+      return check("assert")(true)(AssertProgrammer.write);
+    // CLONE
+    else if (category === "assertClone")
+      return misc("assert")(MiscAssertCloneProgrammer.write);
+    else if (category === "validateClone")
+      return misc("validate")(MiscValidateCloneProgrammer.write);
+    // PRUNE
+    else if (category === "assertPrune")
+      return misc("assert")(MiscAssertPruneProgrammer.write);
+    else if (category === "validatePrune")
+      return misc("validate")(MiscValidatePruneProgrammer.write);
+    // DEFAULT
+    return check("assert")(false)(AssertProgrammer.write);
+  };
 }

package/src/programmers/TypedFormDataBodyProgrammer.ts

@@ -7,101 +7,111 @@ import { HttpFormDataProgrammer } from "typia/lib/programmers/http/HttpFormDataP
 import { HttpIsFormDataProgrammer } from "typia/lib/programmers/http/HttpIsFormDataProgrammer";
 import { HttpValidateFormDataProgrammer } from "typia/lib/programmers/http/HttpValidateFormDataProgrammer";
 import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 import { TransformerError } from "typia/lib/transformers/TransformerError";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { IRequestFormDataProps } from "../options/IRequestFormDataProps";
 
 export namespace TypedFormDataBodyProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ObjectLiteralExpression => {
-      // VALIDATE TYPE
-      const collection: MetadataCollection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.context,
-      )({
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ObjectLiteralExpression => {
+    // VALIDATE TYPE
+    const collection: MetadataCollection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
         escape: false,
         constant: true,
         absorb: true,
         validate: HttpFormDataProgrammer.validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from("nestia.core.TypedFormData.Body")(
-          result.errors,
-        );
+      },
+      type: props.type,
+      collection,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: "nestia.core.TypedFormData.Body",
+        errors: result.errors,
+      });
 
-      const files: IRequestFormDataProps.IFile[] =
-        result.data.objects[0].properties
-          .filter(
-            (p) =>
-              isFile(p.value) ||
-              p.value.arrays.some((a) => isFile(a.type.value)),
-          )
-          .map((p) => ({
-            name: p.key.constants[0].values[0].value as string,
-            limit: !!p.value.natives.length ? 1 : null,
-          }));
+    const files: IRequestFormDataProps.IFile[] =
+      result.data.objects[0].properties
+        .filter(
+          (p) =>
+            isFile(p.value) || p.value.arrays.some((a) => isFile(a.type.value)),
+        )
+        .map((p) => ({
+          name: p.key.constants[0].values[0].value as string,
+          limit: !!p.value.natives.length ? 1 : null,
+        }));
 
-      // GENERATE VALIDATION PLAN
-      const parameter =
-        (key: IRequestFormDataProps<any>["validator"]["type"]) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-          ) => (type: ts.Type) => ts.Expression,
-        ) =>
-          ts.factory.createObjectLiteralExpression(
-            [
-              ts.factory.createPropertyAssignment(
-                ts.factory.createIdentifier("files"),
-                LiteralFactory.generate(files),
-              ),
-              ts.factory.createPropertyAssignment(
-                ts.factory.createIdentifier("validator"),
-                ts.factory.createObjectLiteralExpression(
-                  [
-                    ts.factory.createPropertyAssignment(
-                      ts.factory.createIdentifier("type"),
-                      ts.factory.createStringLiteral(key),
-                    ),
-                    ts.factory.createPropertyAssignment(
-                      ts.factory.createIdentifier(key),
-                      programmer({
-                        ...project,
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestFormDataProps<any>["validator"]["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        ts.factory.createObjectLiteralExpression(
+          [
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("files"),
+              LiteralFactory.write(files),
+            ),
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("validator"),
+              ts.factory.createObjectLiteralExpression(
+                [
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("type"),
+                    ts.factory.createStringLiteral(key),
+                  ),
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier(key),
+                    programmer({
+                      context: {
+                        ...props.context,
                         options: {
                           numeric: false,
                           finite: false,
                           functional: false,
                         },
-                      })(modulo)(type),
-                    ),
-                  ],
-                  true,
-                ),
+                      },
+                      modulo: props.modulo,
+                      type: props.type,
+                      name: undefined,
+                    }),
+                  ),
+                ],
+                true,
               ),
-            ],
-            true,
-          );
+            ),
+          ],
+          true,
+        );
 
-      // RETURNS
-      const category = project.options.validate;
-      if (category === "is" || category === "equals")
-        return parameter("is")(HttpIsFormDataProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateFormDataProgrammer.write);
-      return parameter("assert")(HttpAssertFormDataProgrammer.write);
-    };
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsFormDataProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateFormDataProgrammer.write);
+    return parameter("assert")(HttpAssertFormDataProgrammer.write);
+  };
 }
 
 const isFile = (meta: Metadata) =>

package/src/programmers/TypedHeadersProgrammer.ts

@@ -2,55 +2,62 @@ import ts from "typescript";
 import { HttpAssertHeadersProgrammer } from "typia/lib/programmers/http/HttpAssertHeadersProgrammer";
 import { HttpIsHeadersProgrammer } from "typia/lib/programmers/http/HttpIsHeadersProgrammer";
 import { HttpValidateHeadersProgrammer } from "typia/lib/programmers/http/HttpValidateHeadersProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { IRequestHeadersValidator } from "../options/IRequestHeadersValidator";
 
 export namespace TypedHeadersProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE VALIDATION PLAN
-      const parameter =
-        (key: IRequestHeadersValidator<any>["type"]) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-          ) => (type: ts.Type) => ts.Expression,
-        ) =>
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("type"),
-              ts.factory.createStringLiteral(key),
-            ),
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier(key),
-              programmer({
-                ...project,
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestHeadersValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => ts.Expression,
+      ) =>
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier("type"),
+            ts.factory.createStringLiteral(key),
+          ),
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier(key),
+            programmer({
+              context: {
+                ...props.context,
                 options: {
                   numeric: false,
                   finite: false,
                   functional: false,
                 },
-              })(modulo)(type),
-            ),
-          ]);
+              },
+              modulo: props.modulo,
+              type: props.type,
+              name: undefined,
+            }),
+          ),
+        ]);
 
-      // RETURNS
-      const category = project.options.validate;
-      if (category === "is" || category === "equals")
-        return parameter("is")(HttpIsHeadersProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateHeadersProgrammer.write);
-      return parameter("assert")(HttpAssertHeadersProgrammer.write);
-    };
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsHeadersProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateHeadersProgrammer.write);
+    return parameter("assert")(HttpAssertHeadersProgrammer.write);
+  };
 }

package/src/programmers/TypedParamProgrammer.ts

@@ -1,24 +1,30 @@
 import ts from "typescript";
 import { HttpParameterProgrammer } from "typia/lib/programmers/http/HttpParameterProgrammer";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 
 export namespace TypedParamProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (parameters: readonly ts.Expression[]) =>
-    (type: ts.Type): readonly ts.Expression[] => {
-      // ALREADY BEING TRANSFORMED
-      if (parameters.length !== 1) return parameters;
-      return [
-        parameters[0],
-        HttpParameterProgrammer.write({
-          ...project,
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    arguments: readonly ts.Expression[];
+    type: ts.Type;
+  }): readonly ts.Expression[] => {
+    // ALREADY BEING TRANSFORMED
+    if (props.arguments.length !== 1) return props.arguments;
+    return [
+      props.arguments[0],
+      HttpParameterProgrammer.write({
+        context: {
+          ...props.context,
           options: {
             numeric: true,
           },
-        })(modulo)(type),
-      ];
-    };
+        },
+        modulo: props.modulo,
+        type: props.type,
+        name: undefined,
+      }),
+    ];
+  };
 }