typia 5.0.0-dev.20230827 → 5.0.0-dev.20230828

package/src/factories/ProtobufFactory.ts

@@ -5,6 +5,10 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 
 import { ProtobufUtil } from "../programmers/helpers/ProtobufUtil";
 
+import { TransformerError } from "../transformers/TransformerError";
+
+import { ValidationPipe } from "../typings/ValidationPipe";
+
 import { Escaper } from "../utils/Escaper";
 
 import { MetadataCollection } from "./MetadataCollection";
@@ -15,65 +19,72 @@ export namespace ProtobufFactory {
         (method: string) =>
         (checker: ts.TypeChecker) =>
         (collection: MetadataCollection) =>
-        (type: ts.Type) => {
+        (type: ts.Type): Metadata => {
             // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
-            const top: Metadata = MetadataFactory.analyze(checker)({
-                escape: false,
-                constant: true,
-                absorb: true,
-                validate: validate(method),
-            })(collection)(type);
+            const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+                MetadataFactory.analyze(checker)({
+                    escape: false,
+                    constant: true,
+                    absorb: true,
+                    validate,
+                })(collection)(type);
+            if (result.success === false)
+                throw TransformerError.from(`typia.protobuf.${method}`)(
+                    result.errors,
+                );
+            return result.data;
+        };
+
+    const validate = (
+        meta: Metadata,
+        explore: MetadataFactory.IExplore,
+    ): string[] => {
+        const errors: string[] = [];
+        const insert = (msg: string) => errors.push(msg);
 
-            // TOP LEVEL TYPE MUST BE A SINGLE OBJECT
+        if (explore.top === true) {
             const onlyObject: boolean =
-                top.size() === 1 &&
-                top.objects.length === 1 &&
-                top.objects[0]!.properties.every((p) =>
+                meta.size() === 1 &&
+                meta.objects.length === 1 &&
+                meta.objects[0]!.properties.every((p) =>
                     p.key.isSoleLiteral(),
                 ) &&
-                top.isRequired() === true &&
-                top.nullable === false;
+                meta.isRequired() === true &&
+                meta.nullable === false;
             if (onlyObject === false)
-                throw new Error(
-                    `${prefix(
-                        method,
-                    )} target type must be a sole and static object.`,
-                );
-
-            return top;
-        };
+                insert("target type must be a sole and static object type");
+            return errors;
+        }
 
-    const validate = (method: string) => (meta: Metadata) => {
         //----
         // NOT SUPPORTED TYPES
         //----
+        const noSupport = (msg: string) => insert(`does not support ${msg}`);
+
         // PROHIBIT ANY TYPE
-        if (meta.any) throw notSupportedError({ method })("any type");
+        if (meta.any) noSupport("any type");
         // PROHIBIT FUNCTIONAL TYPE
-        else if (meta.functional)
-            throw notSupportedError({ method })("functional type");
+        if (meta.functional) noSupport("functional type");
         // PROHIBIT TUPLE TYPE
-        else if (meta.tuples.length)
-            throw notSupportedError({ method })("tuple type");
+        if (meta.tuples.length) noSupport("tuple type");
         // PROHIBIT SET TYPE
-        else if (meta.sets.length)
-            throw notSupportedError({ method })("Set type");
+        if (meta.sets.length) noSupport("Set type");
         // NATIVE TYPE, BUT NOT Uint8Array
-        else if (meta.natives.length) {
+        if (meta.natives.length) {
             const banned = meta.natives
                 .map((n) => [n, BANNED_NATIVE_TYPES.get(n)] as const)
                 .filter(([_n, b]) => b !== undefined)[0];
             if (banned !== undefined)
-                throw notSupportedError({ method })(
+                noSupport(
                     banned[1] === null
-                        ? banned[0]
-                        : `${banned[0]}. Use ${banned[1]} instead.`,
+                        ? `${banned[0]} type`
+                        : `does ${banned[0]} type. Use ${banned[1]} type instead.`,
                 );
         }
         //----
         // ATOMIC CASES
         //----
-        else if (meta.atomics.length) {
+        if (meta.atomics.length) {
             const numbers = ProtobufUtil.getNumbers(meta);
             const bigints = ProtobufUtil.getBigints(meta);
 
@@ -82,21 +93,21 @@ export namespace ProtobufFactory {
                     numbers.some((n) => n === type) &&
                     bigints.some((b) => b === type)
                 )
-                    throw notSupportedError({ method })(
-                        `${type} cannot be used in both number and bigint types. Recommend to remove from number type`,
+                    insert(
+                        `tags.Type<"${type}"> cannot be used in both number and bigint types. Recommend to remove from number type`,
                     );
         }
         //----
         // ARRRAY CASES
         //----
         // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
-        else if (
+        if (
             meta.arrays.length &&
             meta.arrays.some((array) => !!array.type.value.arrays.length)
         )
-            throw notSupportedError({ method })("two dimenstional array type");
+            noSupport("over two dimenstional array type");
         // CHILD OF ARRAY TYPE MUST BE REQUIRED
-        else if (
+        if (
             meta.arrays.length &&
             meta.arrays.some(
                 (array) =>
@@ -104,15 +115,15 @@ export namespace ProtobufFactory {
                     array.type.value.nullable === true,
             )
         )
-            throw notSupportedError({ method })("optional type in array");
+            noSupport("optional type in array");
         // UNION IN ARRAY
-        else if (
+        if (
             meta.arrays.length &&
             meta.arrays.some((a) => a.type.value.size() > 1)
         )
-            throw notSupportedError({ method })("union type in array");
+            noSupport("union type in array");
         // DO DYNAMIC OBJECT IN ARRAY
-        else if (
+        if (
             meta.arrays.length &&
             meta.arrays.some(
                 (a) =>
@@ -123,21 +134,21 @@ export namespace ProtobufFactory {
                         )),
             )
         )
-            throw notSupportedError({ method })("dynamic object in array");
+            noSupport("dynamic object in array");
         // UNION WITH ARRAY
-        else if (meta.size() > 1 && meta.arrays.length)
-            throw notSupportedError({ method })("union type with array type");
+        if (meta.size() > 1 && meta.arrays.length)
+            noSupport("union type with array type");
         //----
         // OBJECT CASES
         //----
         // EMPTY PROPERTY
-        else if (
+        if (
             meta.objects.length &&
             meta.objects.some((obj) => obj.properties.length === 0)
         )
-            throw notSupportedError({ method })("empty object type");
+            noSupport("empty object type");
         // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
-        else if (
+        if (
             meta.objects.length &&
             meta.objects.some(
                 (obj) =>
@@ -145,11 +156,11 @@ export namespace ProtobufFactory {
                         .length > 1,
             )
         )
-            throw notSupportedError({ method })(
+            noSupport(
                 "object type with multiple dynamic key typed properties. Keep only one.",
             );
         // STATIC AND DYNAMIC PROPERTIES ARE COMPATIBLE
-        else if (
+        if (
             meta.objects.length &&
             meta.objects.some(
                 (obj) =>
@@ -157,11 +168,11 @@ export namespace ProtobufFactory {
                     obj.properties.some((p) => !p.key.isSoleLiteral()),
             )
         )
-            throw notSupportedError({ method })(
+            noSupport(
                 "object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.",
             );
         // STATIC PROPERTY, BUT INVALID KEY NAME
-        else if (
+        if (
             meta.objects.length &&
             meta.objects.some((obj) =>
                 obj.properties.some(
@@ -171,29 +182,23 @@ export namespace ProtobufFactory {
                 ),
             )
         )
-            throw notSupportedError({ method })(
-                `object type with invalid static key name.`,
-            );
+            throw noSupport(`object type with invalid static key name.`);
         // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
-        else if (
+        if (
             meta.objects.length &&
             isDynamicObject(meta.objects[0]!) &&
             meta.objects[0]!.properties.some((p) => !!p.value.arrays.length)
         )
-            throw notSupportedError({ method })(
-                "dynamic object with array value type",
-            );
+            noSupport("dynamic object with array value type");
         // UNION WITH DYNAMIC OBJECT
-        else if (
+        if (
             meta.size() > 1 &&
             meta.objects.length &&
             isDynamicObject(meta.objects[0]!)
         )
-            throw notSupportedError({ method })(
-                "union type with dynamic object type",
-            );
+            noSupport("union type with dynamic object type");
         // UNION IN DYNAMIC PROPERTY VALUE
-        else if (
+        if (
             meta.objects.length &&
             meta.objects.some(
                 (obj) =>
@@ -201,59 +206,47 @@ export namespace ProtobufFactory {
                     obj.properties.some((p) => ProtobufUtil.isUnion(p.value)),
             )
         )
-            throw notSupportedError({ method })(
-                "union type in dynamic property",
-            );
+            noSupport("union type in dynamic property");
         //----
         // MAP CASES
         //----
-        // KEY TYPE ISUNION
-        else if (
+        // KEY TYPE IS UNION
+        if (
             meta.maps.length &&
             meta.maps.some((m) => ProtobufUtil.isUnion(m.key))
         )
-            throw notSupportedError({ method })("union key typed map");
+            noSupport("union key typed map");
         // KEY TYPE IS NOT ATOMIC
-        else if (
+        if (
             meta.maps.length &&
             meta.maps.some((m) => ProtobufUtil.getAtomics(m.key).length !== 1)
         )
-            throw notSupportedError({ method })("non-atomic key typed map");
+            noSupport("non-atomic key typed map");
         // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
-        else if (
+        if (
             meta.maps.length &&
             meta.maps.some(
                 (m) => m.key.isRequired() === false || m.key.nullable,
             )
         )
-            throw notSupportedError({ method })("optional key typed map");
+            noSupport("optional key typed map");
         // MAP TYPE, BUT VALUE TYPE IS ARRAY
-        else if (
-            meta.maps.length &&
-            meta.maps.some((m) => !!m.value.arrays.length)
-        )
-            throw notSupportedError({ method })(
-                "map type with array value type",
-            );
+        if (meta.maps.length && meta.maps.some((m) => !!m.value.arrays.length))
+            noSupport("map type with array value type");
         // UNION WITH MAP
-        else if (meta.size() > 1 && meta.maps.length)
-            throw notSupportedError({ method })("union type with map type");
+        if (meta.size() > 1 && meta.maps.length)
+            noSupport("union type with map type");
         // UNION IN MAP
-        else if (
+        if (
             meta.maps.length &&
             meta.maps.some((m) => ProtobufUtil.isUnion(m.value))
         )
-            throw notSupportedError({ method })("union type in map");
+            noSupport("union type in map");
+
+        return errors;
     };
 }
 
-const prefix = (method: string) => `Error on ${method}():`;
-
-const notSupportedError = (p: { method: string }) => (title: string) =>
-    new Error(
-        `${prefix(p.method)}: protocol buffer does not support ${title}.`,
-    );
-
 const isDynamicObject = (obj: MetadataObject): boolean =>
     obj.properties[0]!.key.isSoleLiteral() === false;
 

package/src/factories/TypeFactory.ts

@@ -1,11 +1,6 @@
 import ts from "typescript";
 
 export namespace TypeFactory {
-    export const resolve =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type): ts.Type | null =>
-            getReturnType(checker)(type)("toJSON");
-
     export const isFunction = (type: ts.Type): boolean =>
         getFunction(type) !== null;
 

package/src/factories/internal/metadata/emplace_metadata_alias.ts

@@ -13,7 +13,12 @@ export const emplace_metadata_alias =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataAlias => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        type: ts.Type,
+        nullable: boolean,
+        explore: MetadataFactory.IExplore,
+    ): MetadataAlias => {
         // CHECK EXISTENCE
         const [alias, newbie, closure] = collection.emplaceAlias(
             checker,
@@ -25,10 +30,12 @@ export const emplace_metadata_alias =
 
         // CONSTRUCT VALUE TYPE
         const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type,
-            false,
-            true,
-        );
+            errors,
+        )(type, {
+            ...explore,
+            escaped: false,
+            aliased: true,
+        });
         closure(value);
         return alias;
     };

package/src/factories/internal/metadata/emplace_metadata_array_type.ts

@@ -13,7 +13,12 @@ export const emplace_metadata_array_type =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataArrayType => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        type: ts.Type,
+        nullable: boolean,
+        explore: MetadataFactory.IExplore,
+    ): MetadataArrayType => {
         // CHECK EXISTENCE
         const [array, newbie, setValue] = collection.emplaceArray(
             checker,
@@ -24,10 +29,12 @@ export const emplace_metadata_array_type =
 
         // CONSTRUCT VALUE TYPE
         const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type.getNumberIndexType()!,
-            false,
-            false,
-        );
+            errors,
+        )(type.getNumberIndexType()!, {
+            ...explore,
+            escaped: false,
+            aliased: false,
+        });
         setValue(value);
 
         return array;

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -18,6 +18,7 @@ export const emplace_metadata_object =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (parent: ts.Type, nullable: boolean): MetadataObject => {
         // EMPLACE OBJECT
         const [obj, newbie] = collection.emplace(checker, parent);
@@ -99,7 +100,14 @@ export const emplace_metadata_object =
             const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
             const value: Metadata = explore_metadata(checker)(options)(
                 collection,
-            )(type, false);
+            )(errors)(type, {
+                top: false,
+                object: obj,
+                property: prop.name,
+                nested: null,
+                escaped: false,
+                aliased: false,
+            });
 
             // OPTIONAL, BUT CAN BE RQUIRED BY `Required<T>` TYPE
             if (node?.questionToken) Writable(value).optional = true;
@@ -111,10 +119,17 @@ export const emplace_metadata_object =
         //----
         for (const index of checker.getIndexInfosOfType(parent)) {
             // GET EXACT TYPE
-            const analyzer = (type: ts.Type) =>
-                explore_metadata(checker)(options)(collection)(type, false);
-            const key: Metadata = analyzer(index.keyType);
-            const value: Metadata = analyzer(index.type);
+            const analyzer = (type: ts.Type) => (property: {} | null) =>
+                explore_metadata(checker)(options)(collection)(errors)(type, {
+                    top: false,
+                    object: obj,
+                    property,
+                    nested: null,
+                    escaped: false,
+                    aliased: false,
+                });
+            const key: Metadata = analyzer(index.keyType)(null);
+            const value: Metadata = analyzer(index.type)({});
 
             // INSERT WITH REQUIRED CONFIGURATION
             insert(key)(value)(

package/src/factories/internal/metadata/emplace_metadata_tuple.ts

@@ -15,7 +15,12 @@ export const emplace_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.TupleType, nullable: boolean): MetadataTupleType => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        type: ts.TupleType,
+        nullable: boolean,
+        explore: MetadataFactory.IExplore,
+    ): MetadataTupleType => {
         // CHECK EXISTENCE
         const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
         ArrayUtil.add(tuple.nullables, nullable);
@@ -31,7 +36,12 @@ export const emplace_metadata_tuple =
             .map((elem, i) => {
                 const child: Metadata = explore_metadata(checker)(options)(
                     collection,
-                )(elem, false, false);
+                )(errors)(elem, {
+                    ...explore,
+                    nested: tuple,
+                    aliased: false,
+                    escaped: false,
+                });
 
                 // CHECK OPTIONAL
                 const flag: ts.ElementFlags | undefined = flagList[i];

package/src/factories/internal/metadata/explore_metadata.ts

@@ -11,23 +11,17 @@ export const explore_metadata =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (
-        type: ts.Type | null,
-        parentResolved: boolean,
-        aliased: boolean = false,
-    ): Metadata => {
+    (errors: MetadataFactory.IError[]) =>
+    (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
         // CONSTRUCT METADATA
-        const meta: Metadata = Metadata.initialize(parentResolved);
-        collection.entire_.add(meta);
-
+        const meta: Metadata = Metadata.initialize(explore.escaped);
         if (type === null) return meta;
 
         // ITERATE TYPESCRIPT TYPES
-        iterate_metadata(checker)(options)(collection)(
+        iterate_metadata(checker)(options)(collection)(errors)(
             meta,
             type,
-            parentResolved,
-            aliased,
+            explore,
         );
         emend_metadata_atomics(meta);
         if (meta.escaped) {

package/src/factories/internal/metadata/iterate_metadata.ts

@@ -2,9 +2,9 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-// import { ArrayUtil } from "../../../utils/ArrayUtil";
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata_alias } from "./iterate_metadata_alias";
 import { iterate_metadata_array } from "./iterate_metadata_array";
 import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
@@ -24,39 +24,42 @@ export const iterate_metadata =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (
         meta: Metadata,
         type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
+        explore: MetadataFactory.IExplore,
     ): void => {
-        if (type.isTypeParameter() === true)
-            throw new Error(
-                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
-            );
+        if (type.isTypeParameter() === true) {
+            errors.push({
+                name: TypeFactory.getFullName(checker)(type),
+                explore: { ...explore },
+                messages: ["non-specified generic argument found."],
+            });
+            return;
+        }
         // CHECK SPECIAL CASES
-        if (
-            (aliased !== true &&
-                iterate_metadata_alias(checker)(options)(collection)(
+        else if (
+            (explore.aliased !== true &&
+                iterate_metadata_alias(checker)(options)(collection)(errors)(
                     meta,
                     type,
+                    explore,
                 )) ||
-            iterate_metadata_intersection(checker)(options)(collection)(
+            iterate_metadata_intersection(checker)(options)(collection)(errors)(
                 meta,
                 type,
-                resolved,
-                aliased,
+                explore,
             ) ||
-            iterate_metadata_union(checker)(options)(collection)(
+            iterate_metadata_union(checker)(options)(collection)(errors)(
                 meta,
                 type,
-                resolved,
+                explore,
             ) ||
-            iterate_metadata_resolve(checker)(options)(collection)(
+            iterate_metadata_resolve(checker)(options)(collection)(errors)(
                 meta,
                 type,
-                resolved,
-                aliased,
+                explore,
             )
         )
             return;
@@ -64,18 +67,35 @@ export const iterate_metadata =
         // ITERATE CASES
         iterate_metadata_coalesce(meta, type) ||
             iterate_metadata_constant(checker)(options)(meta, type) ||
-            iterate_metadata_template(checker)(options)(collection)(
+            iterate_metadata_template(checker)(options)(collection)(errors)(
                 meta,
                 type,
+                explore,
             ) ||
             iterate_metadata_atomic(meta, type) ||
-            iterate_metadata_tuple(checker)(options)(collection)(
+            iterate_metadata_tuple(checker)(options)(collection)(errors)(
                 meta,
                 type as ts.TupleType,
+                explore,
+            ) ||
+            iterate_metadata_array(checker)(options)(collection)(errors)(
+                meta,
+                type,
+                explore,
             ) ||
-            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
             iterate_metadata_native(checker)(meta, type) ||
-            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_object(checker)(options)(collection)(meta, type);
+            iterate_metadata_map(checker)(options)(collection)(errors)(
+                meta,
+                type,
+                explore,
+            ) ||
+            iterate_metadata_set(checker)(options)(collection)(errors)(
+                meta,
+                type,
+                explore,
+            ) ||
+            iterate_metadata_object(checker)(options)(collection)(errors)(
+                meta,
+                type,
+            );
     };

package/src/factories/internal/metadata/iterate_metadata_alias.ts

@@ -13,7 +13,12 @@ export const iterate_metadata_alias =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (options.absorb !== false || type.aliasSymbol === undefined)
             return false;
 
@@ -24,7 +29,7 @@ export const iterate_metadata_alias =
         // CONSTRUCT DEFINITION
         const alias: MetadataAlias = emplace_metadata_alias(checker)(options)(
             collection,
-        )(type, meta.nullable);
+        )(errors)(type, meta.nullable, explore);
         ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
         return true;
     };

package/src/factories/internal/metadata/iterate_metadata_array.ts

@@ -14,12 +14,17 @@ export const iterate_metadata_array =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!checker.isArrayType(type)) return false;
 
         const arrayType: MetadataArrayType = emplace_metadata_array_type(
             checker,
-        )(options)(collection)(type, meta.nullable);
+        )(options)(collection)(errors)(type, meta.nullable, explore);
         ArrayUtil.add(
             meta.arrays,
             MetadataArray.create({