@nestia/core 2.4.2 → 2.4.3

package/src/programmers/PlainBodyProgrammer.ts

@@ -1,56 +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("@core.nestia.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("@core.nestia.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/TypedBodyProgrammer.ts

@@ -1,112 +1,108 @@
-import ts from "typescript";
-
-import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { MiscAssertCloneProgrammer } from "typia/lib/programmers/misc/MiscAssertCloneProgrammer";
-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 { INestiaTransformProject } 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);
-
-            // GENERATE VALIDATION PLAN
-            const check =
-                (key: IRequestBodyValidator<any>["type"]) =>
-                (equals: boolean) =>
-                (
-                    programmer: (
-                        project: IProject,
-                    ) => (
-                        modulo: ts.LeftHandSideExpression,
-                    ) => (
-                        equals: boolean,
-                    ) => (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)(equals)(type),
-                        ),
-                    ]);
-            const misc =
-                (key: IRequestBodyValidator<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;
-            // 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);
-        };
-}
+import ts from "typescript";
+import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
+import { MiscAssertCloneProgrammer } from "typia/lib/programmers/misc/MiscAssertCloneProgrammer";
+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 { INestiaTransformProject } 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,
+      );
+
+      // GENERATE VALIDATION PLAN
+      const check =
+        (key: IRequestBodyValidator<any>["type"]) =>
+        (equals: boolean) =>
+        (
+          programmer: (
+            project: IProject,
+          ) => (
+            modulo: ts.LeftHandSideExpression,
+          ) => (equals: boolean) => (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)(equals)(type),
+            ),
+          ]);
+      const misc =
+        (key: IRequestBodyValidator<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;
+      // 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/TypedExceptionProgrammer.ts

@@ -1,76 +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/TypedHeadersProgrammer.ts

@@ -1,59 +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);
+    };
+}