@nestia/core 2.6.2 → 2.6.3

package/src/options/IRequestFormDataProps.ts

@@ -1,27 +1,27 @@
-import { IValidation } from "typia";
-
-export interface IRequestFormDataProps<T> {
-  files: Array<IRequestFormDataProps.IFile>;
-  validator:
-    | IRequestFormDataProps.IAssert<T>
-    | IRequestFormDataProps.IIs<T>
-    | IRequestFormDataProps.IValidate<T>;
-}
-export namespace IRequestFormDataProps {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: FormData) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: FormData) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: FormData) => IValidation<T>;
-  }
-  export interface IFile {
-    name: string;
-    limit: number | null;
-  }
-}
+import { IValidation } from "typia";
+
+export interface IRequestFormDataProps<T> {
+  files: Array<IRequestFormDataProps.IFile>;
+  validator:
+    | IRequestFormDataProps.IAssert<T>
+    | IRequestFormDataProps.IIs<T>
+    | IRequestFormDataProps.IValidate<T>;
+}
+export namespace IRequestFormDataProps {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: FormData) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: FormData) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: FormData) => IValidation<T>;
+  }
+  export interface IFile {
+    name: string;
+    limit: number | null;
+  }
+}

package/src/programmers/PlainBodyProgrammer.ts

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

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