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

package/src/programmers/TypedQueryBodyProgrammer.ts

@@ -2,55 +2,62 @@ import ts from "typescript";
 import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
 import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
 import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
-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 { IRequestQueryValidator } from "../options/IRequestQueryValidator";
 
 export namespace TypedQueryBodyProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ObjectLiteralExpression => {
-      // GENERATE VALIDATION PLAN
-      const parameter =
-        (key: IRequestQueryValidator<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.ObjectLiteralExpression => {
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestQueryValidator<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")(HttpIsQueryProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateQueryProgrammer.write);
-      return parameter("assert")(HttpAssertQueryProgrammer.write);
-    };
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsQueryProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateQueryProgrammer.write);
+    return parameter("assert")(HttpAssertQueryProgrammer.write);
+  };
 }

package/src/programmers/TypedQueryProgrammer.ts

@@ -2,59 +2,64 @@ import ts from "typescript";
 import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
 import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
 import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
-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 { IRequestQueryValidator } from "../options/IRequestQueryValidator";
 
 export namespace TypedQueryProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE VALIDATION PLAN
-      const parameter =
-        (key: IRequestQueryValidator<any>["type"]) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-            allowOptiona: 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,
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestQueryValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+          allowOptional: boolean;
+        }) => 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,
-                true,
-              )(type),
-            ),
-          ]);
+              },
+              modulo: props.modulo,
+              type: props.type,
+              name: undefined,
+              allowOptional: true,
+            }),
+          ),
+        ]);
 
-      // RETURNS
-      const category = project.options.validate;
-      if (category === "is" || category === "equals")
-        return parameter("is")(HttpIsQueryProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateQueryProgrammer.write);
-      return parameter("assert")(HttpAssertQueryProgrammer.write);
-    };
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsQueryProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateQueryProgrammer.write);
+    return parameter("assert")(HttpAssertQueryProgrammer.write);
+  };
 }

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,51 +1,56 @@
 import ts from "typescript";
-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 { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
 import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
 import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
 import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
 
 export namespace TypedQueryRouteProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE STRINGIFY PLAN
-      const parameter = (
-        key: string,
-        programmer: (
-          project: IProject,
-        ) => (
-          modulo: ts.LeftHandSideExpression,
-        ) => (type: ts.Type) => ts.ArrowFunction,
-      ) =>
-        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 STRINGIFY PLAN
+    const parameter = (
+      key: string,
+      programmer: (next: {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        type: ts.Type;
+      }) => ts.ArrowFunction,
+    ) =>
+      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: {}, // use default option
-            })(modulo)(type),
-          ),
-        ]);
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        ),
+      ]);
 
-      // RETURNS
-      if (project.options.stringify === "is")
-        return parameter("is", HttpIsQuerifyProgrammer.write);
-      else if (project.options.stringify === "validate")
-        return parameter("validate", HttpValidateQuerifyProgrammer.write);
-      else if (project.options.stringify === "stringify")
-        return parameter("stringify", HttpQuerifyProgrammer.write);
-      else if (project.options.stringify === null)
-        return ts.factory.createNull();
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter("is", HttpIsQuerifyProgrammer.write);
+    else if (props.context.options.stringify === "validate")
+      return parameter("validate", HttpValidateQuerifyProgrammer.write);
+    else if (props.context.options.stringify === "stringify")
+      return parameter("stringify", HttpQuerifyProgrammer.write);
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
 
-      // ASSERT IS DEFAULT
-      return parameter("assert", HttpAssertQuerifyProgrammer.write);
-    };
+    // ASSERT IS DEFAULT
+    return parameter("assert", HttpAssertQuerifyProgrammer.write);
+  };
 }

package/src/programmers/TypedRouteProgrammer.ts

@@ -3,72 +3,74 @@ import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAs
 import { JsonIsStringifyProgrammer } from "typia/lib/programmers/json/JsonIsStringifyProgrammer";
 import { JsonStringifyProgrammer } from "typia/lib/programmers/json/JsonStringifyProgrammer";
 import { JsonValidateStringifyProgrammer } from "typia/lib/programmers/json/JsonValidateStringifyProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
+import { IProgrammerProps } from "typia/lib/transformers/IProgrammerProps";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 
 export namespace TypedRouteProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE STRINGIFY PLAN
-      const parameter = (props: {
-        type: string;
-        key: string;
-        programmer: (
-          project: IProject,
-        ) => (
-          modulo: ts.LeftHandSideExpression,
-        ) => (type: ts.Type) => ts.Expression;
-      }) =>
-        ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment(
-            ts.factory.createIdentifier("type"),
-            ts.factory.createStringLiteral(props.type),
-          ),
-          ts.factory.createPropertyAssignment(
-            ts.factory.createIdentifier(props.key),
-            props.programmer({
-              ...project,
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // GENERATE STRINGIFY PLAN
+    const parameter = (next: {
+      type: string;
+      key: string;
+      programmer: (next: IProgrammerProps) => ts.Expression;
+    }) =>
+      ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier("type"),
+          ts.factory.createStringLiteral(next.type),
+        ),
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier(next.key),
+          next.programmer({
+            context: {
+              ...props.context,
               options: {}, // use default option
-            })(modulo)(type),
-          ),
-        ]);
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        ),
+      ]);
 
-      // RETURNS
-      if (project.options.stringify === "is")
-        return parameter({
-          type: "is",
-          key: "is",
-          programmer: JsonIsStringifyProgrammer.write,
-        });
-      else if (project.options.stringify === "validate")
-        return parameter({
-          type: "validate",
-          key: "validate",
-          programmer: JsonValidateStringifyProgrammer.write,
-        });
-      else if (project.options.stringify === "stringify")
-        return parameter({
-          type: "stringify",
-          key: "stringify",
-          programmer: JsonStringifyProgrammer.write,
-        });
-      else if (project.options.stringify === "validate.log")
-        return parameter({
-          type: "validate.log",
-          key: "validate",
-          programmer: JsonValidateStringifyProgrammer.write,
-        });
-      else if (project.options.stringify === null)
-        return ts.factory.createNull();
-
-      // ASSERT IS DEFAULT
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter({
+        type: "is",
+        key: "is",
+        programmer: JsonIsStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate")
+      return parameter({
+        type: "validate",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "stringify")
+      return parameter({
+        type: "stringify",
+        key: "stringify",
+        programmer: JsonStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate.log")
       return parameter({
-        type: "assert",
-        key: "assert",
-        programmer: JsonAssertStringifyProgrammer.write,
+        type: "validate.log",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
       });
-    };
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
+
+    // ASSERT IS DEFAULT
+    return parameter({
+      type: "assert",
+      key: "assert",
+      programmer: JsonAssertStringifyProgrammer.write,
+    });
+  };
 }

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -2,57 +2,71 @@ import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
 import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
 
 import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
 
 export namespace HttpAssertQuerifyProgrammer {
-  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(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "assert",
+          value: AssertProgrammer.write({
+            context: {
+              ...props.context,
               options: {
-                ...project.options,
+                ...props.context.options,
                 functional: false,
                 numeric: false,
               },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            HttpQuerifyProgrammer.write({
-              ...project,
+            },
+            modulo: props.modulo,
+            config: {
+              equals: false,
+              guard: false,
+            },
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
               options: {
-                ...project.options,
+                ...props.context.options,
                 functional: false,
                 numeric: false,
               },
-            })(modulo)(type),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("assert"),
-                  undefined,
-                  [ts.factory.createIdentifier("input")],
-                ),
-              ],
-            ),
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("stringify"),
+            undefined,
+            [
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ],
           ),
-        ]),
-      );
+        ),
+      ]),
+    );
 }