@nestia/core 3.1.0-dev.20240429 → 3.1.0-dev.20240430

package/src/programmers/TypedExceptionProgrammer.ts

@@ -1,71 +1,71 @@
-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,
-            },
-          },
-        ]);
-      // CHECK DUPLICATED TRNASFORMATION
-      else if (expression.arguments.length === 3) return expression;
-
-      // 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);
-
-      // 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,
+            },
+          },
+        ]);
+      // CHECK DUPLICATED TRNASFORMATION
+      else if (expression.arguments.length === 3) return expression;
+
+      // 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);
+
+      // 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/TypedHeadersProgrammer.ts

@@ -1,56 +1,56 @@
-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 { INestiaTransformProject } 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.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")(HttpIsHeadersProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateHeadersProgrammer.write);
-      return parameter("assert")(HttpAssertHeadersProgrammer.write);
-    };
-}
+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 { INestiaTransformProject } 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.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")(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,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,56 +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,56 +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,51 +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);
+    };
+}