typia 5.0.0-dev.2023084 → 5.0.0

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,111 +1,116 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace JsonApplicationTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            //----
-            // GET ARGUMENTS
-            //----
-            // VALIDATE TUPLE ARGUMENTS
-            const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
-                return expression;
-
-            // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
-            );
-            if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
-
-            // ADDITIONAL PARAMETERS
-            const purpose: "swagger" | "ajv" = get_parameter(
-                checker,
-                "Purpose",
-                expression.typeArguments[1],
-                (str) => str === "swagger" || str === "ajv",
-                () => "swagger",
-            );
-
-            //----
-            // GENERATORS
-            //----
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    escape: true,
-                    constant: true,
-                    absorb: false,
-                    validate: (meta) => {
-                        if (meta.atomics.find((atom) => atom.type === "bigint"))
-                            throw new Error(NO_BIGIT);
-                        else if (
-                            meta.arrays.some(
-                                (array) => array.value.isRequired() === false,
-                            )
-                        )
-                            throw new Error(NO_UNDEFINED_IN_ARRAY);
-                    },
-                })(collection)(type),
-            );
-
-            // APPLICATION
-            const app: IJsonApplication = JsonApplicationProgrammer.write({
-                purpose,
-            })(metadatas);
-
-            // RETURNS WITH LITERAL EXPRESSION
-            return LiteralFactory.generate(app);
-        };
-
-    const get_parameter = <T extends string>(
-        checker: ts.TypeChecker,
-        name: string,
-        node: ts.TypeNode | undefined,
-        predicator: (value: string) => boolean,
-        defaulter: () => T,
-    ): T => {
-        if (!node) return defaulter();
-
-        // CHECK LITERAL TYPE
-        const type: ts.Type = checker.getTypeFromTypeNode(node);
-        if (!type.isLiteral())
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
-
-        // GET VALUE AND VALIDATE IT
-        const value = type.value;
-        if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
-        return value as T;
-    };
-}
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.json.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.json.application(): non-specified generic argument(s).";
-const NO_BIGIT =
-    "Error on typia.json.application(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.application(): does not allow undefined type in array.";
+import ts from "typescript";
+
+import { JsonMetadataFactory } from "../../../factories/JsonMetadataFactory";
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonApplicationTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "no generic argument.",
+                });
+
+            //----
+            // GET ARGUMENTS
+            //----
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "non-specified generic argument(s).",
+                });
+
+            // ADDITIONAL PARAMETERS
+            const purpose: "swagger" | "ajv" = get_parameter(
+                checker,
+                "Purpose",
+                expression.typeArguments[1],
+                (str) => str === "swagger" || str === "ajv",
+                () => "swagger",
+            );
+
+            //----
+            // GENERATORS
+            //----
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+                types.map((type) =>
+                    MetadataFactory.analyze(checker)({
+                        escape: true,
+                        constant: true,
+                        absorb: false,
+                        validate: JsonMetadataFactory.validate,
+                    })(collection)(type),
+                );
+
+            // REPORT BUG IF REQUIRED
+            const metadatas: Metadata[] = [];
+            const errors: MetadataFactory.IError[] = [];
+            for (const r of results) {
+                if (r.success === false) errors.push(...r.errors);
+                else metadatas.push(r.data);
+            }
+            if (errors.length)
+                throw TransformerError.from("typia.json.application")(errors);
+
+            // APPLICATION
+            const app: IJsonApplication = JsonApplicationProgrammer.write({
+                purpose,
+            })(metadatas);
+
+            // RETURNS WITH LITERAL EXPRESSION
+            return LiteralFactory.generate(app);
+        };
+
+    const get_parameter = <T extends string>(
+        checker: ts.TypeChecker,
+        name: string,
+        node: ts.TypeNode | undefined,
+        predicator: (value: string) => boolean,
+        defaulter: () => T,
+    ): T => {
+        if (!node) return defaulter();
+
+        // CHECK LITERAL TYPE
+        const type: ts.Type = checker.getTypeFromTypeNode(node);
+        if (!type.isLiteral())
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `generic argument "${name}" must be constant.`,
+            });
+
+        // GET VALUE AND VALIDATE IT
+        const value = type.value;
+        if (typeof value !== "string" || predicator(value) === false)
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `invalid value on generic argument "${name}".`,
+            });
+        return value as T;
+    };
+}

package/src/transformers/features/misc/MetadataTransformer.ts

@@ -1,53 +1,61 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { IProject } from "../../IProject";
-
-export namespace MetadataTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            // VALIDATE TUPLE ARGUMENTS
-            const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
-                return expression;
-
-            // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
-            );
-            if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
-
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    escape: true,
-                    constant: true,
-                    absorb: true,
-                })(collection)(type),
-            );
-
-            // CONVERT TO PRIMITIVE TYPE
-            const app: IMetadataApplication = {
-                metadatas: metadatas.map((metadata) => metadata.toJSON()),
-                collection: collection.toJSON(),
-            };
-            return LiteralFactory.generate(app);
-        };
-}
-
-const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.metadata(): non-specified generic argument(s).";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace MetadataTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new TransformerError({
+                    code: "typia.metadata",
+                    message: "no generic argument.",
+                });
+
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new TransformerError({
+                    code: "typia.metadata",
+                    message: "non-specified generic argument(s).",
+                });
+
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadatas: Array<Metadata> = types.map((type) => {
+                const result = MetadataFactory.analyze(checker)({
+                    escape: true,
+                    constant: true,
+                    absorb: true,
+                })(collection)(type);
+                if (result.success === false)
+                    throw TransformerError.from("typia.metadata")(
+                        result.errors,
+                    );
+                return result.data;
+            });
+
+            // CONVERT TO PRIMITIVE TYPE
+            const app: IMetadataApplication = {
+                metadatas: metadatas.map((metadata) => metadata.toJSON()),
+                collection: collection.toJSON(),
+            };
+            return LiteralFactory.generate(app);
+        };
+}

package/src/transformers/features/misc/MiscCreateIsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateIsPruneTransformer {
     export const transform = GenericTransformer.factory("createIsPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscIsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscIsPruneTransformer {
     export const transform = GenericTransformer.scalar("isPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscLiteralsTransformer.ts

@@ -3,26 +3,30 @@ import ts from "typescript";
 import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace MiscLiteralsTransformer {
     export const transform =
         (project: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.misc.literals",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.misc.literals",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return MiscLiteralsProgrammer.write(project)(type);
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.literals(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.literals(): non-specified generic argument.";

package/src/transformers/features/protobuf/ProtobufMessageTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace ProtobufMessageTransformer {
     export const transform =
@@ -11,21 +12,22 @@ export namespace ProtobufMessageTransformer {
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(ErrorMessages.NOT_SPECIFIED);
+                throw new TransformerError({
+                    code: "typia.protobuf.message",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const type: ts.Type = project.checker.getTypeFromTypeNode(
                 expression.typeArguments[0],
             );
             if (type.isTypeParameter())
-                throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "tyipa.protobuf.message",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return ProtobufMessageProgrammer.write(project)(type);
         };
 }
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.protobuf.message(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.protobuf.message(): non-specified generic argument.",
-}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace GenericTransformer {
     export const scalar =
@@ -17,7 +18,10 @@ export namespace GenericTransformer {
         (expression: ts.CallExpression) => {
             // CHECK PARAMETER
             if (expression.arguments.length !== 1)
-                throw new Error(`Error on typia.${method}(): no input value.`);
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `no input value.`,
+                });
 
             // GET TYPE INFO
             const [type, node, generic]: [ts.Type, ts.Node, boolean] =
@@ -37,9 +41,10 @@ export namespace GenericTransformer {
                           false,
                       ];
             if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `non-specified generic argument.`,
+                });
 
             // DO TRANSFORM
             return ts.factory.createCallExpression(
@@ -68,18 +73,20 @@ export namespace GenericTransformer {
         (expression: ts.CallExpression) => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments?.[0])
-                throw new Error(
-                    `Error on typia.${method}(): generic argument is not specified.`,
-                );
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `generic argument is not specified.`,
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
             if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `non-specified generic argument.`,
+                });
 
             // DO TRANSFORM
             return programmer(project)(modulo)(type, node.getFullText().trim());

package/src/typings/Atomic.ts

@@ -1,5 +1,6 @@
 export namespace Atomic {
     export type Type = boolean | number | string | bigint;
+
     export type Literal =
         | "boolean"
         | "integer"

package/src/typings/ProtobufAtomic.ts

@@ -0,0 +1,19 @@
+export type ProtobufAtomic =
+    | "bool"
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "double"
+    | "string";
+export namespace ProtobufAtomic {
+    export type Numeric =
+        | "int32"
+        | "uint32"
+        | "int64"
+        | "uint64"
+        | "float"
+        | "double";
+    export type BigNumeric = "int64" | "uint64";
+}

package/src/typings/ValidationPipe.ts

@@ -0,0 +1,9 @@
+export type ValidationPipe<T, E> =
+    | {
+          success: true;
+          data: T;
+      }
+    | {
+          success: false;
+          errors: E[];
+      };