@nestia/core 2.4.2 → 2.4.3-dev.20231207

package/src/programmers/TypedParamProgrammer.ts

@@ -1,25 +1,24 @@
-import ts from "typescript";
-
-import { HttpParameterProgrammer } from "typia/lib/programmers/http/HttpParameterProgrammer";
-
-import { INestiaTransformProject } 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,
-                    options: {
-                        numeric: true,
-                    },
-                })(modulo)(type),
-            ];
-        };
-}
+import ts from "typescript";
+import { HttpParameterProgrammer } from "typia/lib/programmers/http/HttpParameterProgrammer";
+
+import { INestiaTransformProject } 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,
+          options: {
+            numeric: true,
+          },
+        })(modulo)(type),
+      ];
+    };
+}

package/src/programmers/TypedQueryBodyProgrammer.ts

@@ -1,57 +1,56 @@
-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 { INestiaTransformProject } 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.ArrowFunction,
-                ) =>
-                    ts.factory.createObjectLiteralExpression([
-                        ts.factory.createPropertyAssignment(
-                            ts.factory.createIdentifier("type"),
-                            ts.factory.createStringLiteral(key),
-                        ),
-                        ts.factory.createPropertyAssignment(
-                            ts.factory.createIdentifier(key),
-                            programmer({
-                                ...project,
-                                options: {
-                                    numeric: false,
-                                    finite: false,
-                                    functional: false,
-                                },
-                            })(modulo)(type),
-                        ),
-                    ]);
-
-            // 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);
-        };
-}
+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 { INestiaTransformProject } 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.ArrowFunction,
+        ) =>
+          ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("type"),
+              ts.factory.createStringLiteral(key),
+            ),
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier(key),
+              programmer({
+                ...project,
+                options: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              })(modulo)(type),
+            ),
+          ]);
+
+      // 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);
+    };
+}

package/src/programmers/TypedQueryProgrammer.ts

@@ -1,57 +1,56 @@
-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 { INestiaTransformProject } 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,
-                    ) => (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,
-                                options: {
-                                    numeric: false,
-                                    finite: false,
-                                    functional: false,
-                                },
-                            })(modulo)(type),
-                        ),
-                    ]);
-
-            // 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);
-        };
-}
+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 { INestiaTransformProject } 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,
+          ) => (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,
+                options: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              })(modulo)(type),
+            ),
+          ]);
+
+      // 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);
+    };
+}

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,55 +1,51 @@
-import ts from "typescript";
-
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformProject } 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,
-                            options: {}, // use default option
-                        })(modulo)(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();
-
-            // ASSERT IS DEFAULT
-            return parameter("assert", HttpAssertQuerifyProgrammer.write);
-        };
-}
+import ts from "typescript";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformProject } 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,
+              options: {}, // use default option
+            })(modulo)(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();
+
+      // ASSERT IS DEFAULT
+      return parameter("assert", HttpAssertQuerifyProgrammer.write);
+    };
+}

package/src/programmers/TypedRouteProgrammer.ts

@@ -1,55 +1,51 @@
-import ts from "typescript";
-
-import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
-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 { INestiaTransformProject } from "../options/INestiaTransformProject";
-
-export namespace TypedRouteProgrammer {
-    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,
-                            options: {}, // use default option
-                        })(modulo)(type),
-                    ),
-                ]);
-
-            // RETURNS
-            if (project.options.stringify === "is")
-                return parameter("is", JsonIsStringifyProgrammer.write);
-            else if (project.options.stringify === "validate")
-                return parameter(
-                    "validate",
-                    JsonValidateStringifyProgrammer.write,
-                );
-            else if (project.options.stringify === "stringify")
-                return parameter("stringify", JsonStringifyProgrammer.write);
-            else if (project.options.stringify === null)
-                return ts.factory.createNull();
-
-            // ASSERT IS DEFAULT
-            return parameter("assert", JsonAssertStringifyProgrammer.write);
-        };
-}
+import ts from "typescript";
+import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
+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 { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace TypedRouteProgrammer {
+  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,
+              options: {}, // use default option
+            })(modulo)(type),
+          ),
+        ]);
+
+      // RETURNS
+      if (project.options.stringify === "is")
+        return parameter("is", JsonIsStringifyProgrammer.write);
+      else if (project.options.stringify === "validate")
+        return parameter("validate", JsonValidateStringifyProgrammer.write);
+      else if (project.options.stringify === "stringify")
+        return parameter("stringify", JsonStringifyProgrammer.write);
+      else if (project.options.stringify === null)
+        return ts.factory.createNull();
+
+      // ASSERT IS DEFAULT
+      return parameter("assert", JsonAssertStringifyProgrammer.write);
+    };
+}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -1,59 +1,58 @@
-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 { 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,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "stringify",
-                        HttpQuerifyProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.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")],
-                                ),
-                            ],
-                        ),
-                    ),
-                ]),
-            );
-}
+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 { 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,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "stringify",
+            HttpQuerifyProgrammer.write({
+              ...project,
+              options: {
+                ...project.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")],
+                ),
+              ],
+            ),
+          ),
+        ]),
+      );
+}