typia 5.0.0-dev.20230824 → 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,72 +19,95 @@ 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;
+        };
 
-            // TOP LEVEL TYPE MUST BE A SINGLE OBJECT
+    const validate = (
+        meta: Metadata,
+        explore: MetadataFactory.IExplore,
+    ): string[] => {
+        const errors: string[] = [];
+        const insert = (msg: string) => errors.push(msg);
+
+        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
+        //----
+        if (meta.atomics.length) {
+            const numbers = ProtobufUtil.getNumbers(meta);
+            const bigints = ProtobufUtil.getBigints(meta);
+
+            for (const type of ["int64", "uint64"])
+                if (
+                    numbers.some((n) => n === type) &&
+                    bigints.some((b) => b === 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) =>
@@ -88,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) =>
@@ -107,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) =>
@@ -129,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) =>
@@ -141,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(
@@ -155,91 +182,71 @@ 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) =>
                     isDynamicObject(obj) &&
-                    obj.properties.some((p) => p.value.isBinaryUnion()),
+                    obj.properties.some((p) => ProtobufUtil.isUnion(p.value)),
             )
         )
-            throw notSupportedError({ method })(
-                "union type in dynamic property",
-            );
+            noSupport("union type in dynamic property");
         //----
         // MAP CASES
         //----
-        // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT STRING
-        // @todo -> need to allow other typed keys
-        else if (
+        // KEY TYPE IS UNION
+        if (
             meta.maps.length &&
-            meta.maps.some(
-                (m) =>
-                    m.key.isBinaryUnion() ||
-                    (m.key.atomics.find((v) => v.type === "string") ===
-                        undefined &&
-                        m.key.constants.find((c) => c.type === "string") ===
-                            undefined),
-            )
+            meta.maps.some((m) => ProtobufUtil.isUnion(m.key))
+        )
+            noSupport("union key typed map");
+        // KEY TYPE IS NOT ATOMIC
+        if (
+            meta.maps.length &&
+            meta.maps.some((m) => ProtobufUtil.getAtomics(m.key).length !== 1)
         )
-            throw notSupportedError({ method })("non-string 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) => m.value.isBinaryUnion())
+            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/emend_metadata_atomics.ts

@@ -1,4 +1,5 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -21,7 +22,11 @@ export const emend_metadata_atomics = (meta: Metadata) => {
             ArrayUtil.take(
                 meta.atomics,
                 (a) => a.type === "boolean",
-                () => ({ type: "boolean" as const, tags: [] }),
+                () =>
+                    MetadataAtomic.create({
+                        type: "boolean" as const,
+                        tags: [],
+                    }),
             );
         }
     }

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

@@ -7,14 +7,18 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataTagFactory } from "../../MetadataTagFactory";
 import { explore_metadata } from "./explore_metadata";
 
 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,
@@ -26,15 +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);
-        alias.tags.push(
-            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
-                () => alias.name,
-            ),
-        );
         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);
@@ -61,7 +62,6 @@ export const emplace_metadata_object =
                     value,
                     description,
                     jsDocTags,
-                    tags: [],
                 });
                 obj.properties.push(property);
                 return property;
@@ -100,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;
@@ -112,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,
+            );
     };