typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230827

package/src/factories/MetadataTypeTagFactory.ts

@@ -0,0 +1,263 @@
+import { IMetadataTypeTag } from "../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../schemas/metadata/MetadataProperty";
+
+export namespace MetadataTypeTagFactory {
+    export const analyze =
+        (type: "bigint" | "number" | "string" | "array") =>
+        (objects: MetadataObject[]): IMetadataTypeTag[] => {
+            //----
+            // VALIDATION PROCESS
+            //----
+            const filtered: MetadataObject[] = objects.filter((obj) => {
+                // ONLY ONE PROPERTY
+                if (obj.properties.length !== 1) return false;
+
+                // THE TAG.TYPE PROPERTY MUST BE
+                const top: MetadataProperty = obj.properties[0]!;
+                if (
+                    top.key.getSoleLiteral() !== "typia.tag" ||
+                    top.value.size() !== 1 ||
+                    top.value.objects.length !== 1
+                )
+                    return false;
+                else if (top.value.optional === false)
+                    throw error(null)("must be optional object");
+
+                // CHECK LIST OF PROPERTIES
+                const tag: MetadataObject = top.value.objects[0]!;
+                const statics: string[] = tag.properties
+                    .map((p) => p.key.getSoleLiteral()!)
+                    .filter((str) => str !== null);
+                if (FIELDS.some((f) => !statics.includes(f)))
+                    throw error(null)(
+                        `must have four properties - ${FIELDS.map(
+                            (str) => `'${str}'`,
+                        ).join(", ")}`,
+                    );
+
+                tag.properties.forEach((p) => {
+                    const key: string | null = p.key.getSoleLiteral();
+                    if (key === null) return;
+                    else if (FIELDS.includes(key) === false) return;
+                    validate_property(key, p.value);
+                });
+                return true;
+            });
+            if (filtered.length === 0) return [];
+
+            //----
+            // CONSTRUCT TYPE TAGS
+            //----
+            // CREATE 1ST
+            const tagList: ITypeTag[] = filtered.map(create_metadata_type_tag);
+            const output: IMetadataTypeTag[] = tagList.map((tag) => ({
+                target: tag.target,
+                name: tag.name,
+                kind: tag.kind,
+                value: tag.value,
+                validate: tag.validate[type]!,
+                exclusive: tag.exclusive,
+            }));
+            validate(type)(output);
+            return output;
+        };
+
+    export const validate =
+        (type: "bigint" | "number" | "string" | "array") =>
+        (tagList: IMetadataTypeTag[]) => {
+            for (const tag of tagList)
+                if (tag.target.includes(type))
+                    error(null)(`target must constains ${type} type - ${tag}`);
+
+            tagList.forEach((tag, i) => {
+                if (tag.exclusive === false) return;
+                else if (tag.exclusive === true) {
+                    const some: boolean = tagList.some(
+                        (opposite, j) => i !== j && opposite.kind === tag.kind,
+                    );
+                    if (some === true)
+                        throw error(null)(
+                            `kind '${tag.kind}' can't be duplicated`,
+                        );
+                } else if (Array.isArray(tag.exclusive)) {
+                    const some: IMetadataTypeTag | undefined = tagList.find(
+                        (opposite, j) =>
+                            i !== j &&
+                            opposite.kind === tag.kind &&
+                            (tag.exclusive as string[]).includes(opposite.name),
+                    );
+                    if (some !== undefined)
+                        throw error(null)(
+                            `kind '${tag.kind}' can't be used with '${some.name}'`,
+                        );
+                }
+            });
+        };
+
+    const validate_property = (key: string, value: Metadata) => {
+        if (
+            // TARGET
+            key === "target" &&
+            (value.constants.length !== 1 ||
+                value.constants[0]!.values.length !== value.size() ||
+                value.constants[0]!.values.some(
+                    (v) =>
+                        v !== "bigint" &&
+                        v !== "number" &&
+                        v !== "string" &&
+                        v !== "array",
+                ))
+        )
+            throw error(key)(
+                `must be one of 'bigint', 'number', 'string', 'array'`,
+            );
+        else if (
+            // KIND
+            key === "kind" &&
+            (value.size() !== 1 ||
+                value.constants.length !== 1 ||
+                value.constants[0]!.type !== "string" ||
+                value.constants[0]!.values.length !== 1)
+        )
+            throw error(key)("must be a string literal type");
+        else if (
+            // VALUE
+            key === "value" &&
+            (value.size() > 1 ||
+                (value.size() !== 0 &&
+                    (value.constants.length !== 1 ||
+                        value.constants[0]!.values.length !== 1)))
+        )
+            throw error(key)(
+                "must be a constant literal type or undefined value",
+            );
+        else if (key === "exclusive") get_exclusive(key)(value);
+        else if (key === "validate") {
+            //----
+            // VALIDATE
+            //----
+            // STRING CASE
+            const single: boolean =
+                value.size() === 1 &&
+                value.constants.length === 1 &&
+                value.constants[0]!.type === "string" &&
+                value.constants[0]!.values.length === 1;
+            if (single === true) return;
+
+            // RECORD<TARGET, STRING>
+            const target: string[] | undefined = value.objects[0]?.properties
+                .map((p) => p.key.getSoleLiteral()!)
+                .filter((str) => str !== null) as string[] | undefined;
+            if (target === undefined)
+                throw error("target")(
+                    `must be one of 'bigint', 'number', 'string', 'array'`,
+                );
+            const variadic: boolean =
+                value.size() === 1 &&
+                value.objects.length === 1 &&
+                value.objects[0]!.properties.every(
+                    (vp) =>
+                        vp.value.size() === 1 &&
+                        vp.value.isRequired() &&
+                        vp.value.nullable === false &&
+                        vp.value.constants.length === 1 &&
+                        vp.value.constants[0]!.type === "string" &&
+                        vp.value.constants[0]!.values.length === 1 &&
+                        target.includes(vp.key.getSoleLiteral()!),
+                );
+            if (variadic === false)
+                throw error(key)(
+                    `must be a string literal type or Record<Target, string> type.`,
+                );
+        }
+    };
+
+    const create_metadata_type_tag = (obj: MetadataObject): ITypeTag => {
+        const find = (key: string): MetadataProperty | undefined =>
+            obj.properties[0]?.value.objects[0]?.properties.find(
+                (p) => p.key.getSoleLiteral() === key,
+            );
+
+        const target = find("target")!.value.constants[0]!
+            .values[0] as ITypeTag["target"];
+        const kind: string = find("kind")!.value.constants[0]!
+            .values[0] as string;
+        const value: boolean | bigint | number | string | undefined =
+            find("value")?.value.constants[0]?.values[0];
+        const exclusive: string[] | boolean | undefined = get_exclusive(
+            "exclusive",
+        )(find("exclusive")?.value);
+        const validate: Record<string, string> = (() => {
+            const validate = find("validate")!.value;
+            if (validate.constants.length)
+                return {
+                    [target]: validate.constants[0]!.values[0] as string,
+                };
+            return Object.fromEntries(
+                validate.objects[0]!.properties.map((p) => [
+                    p.key.getSoleLiteral()!,
+                    p.value.constants[0]!.values[0]! as string,
+                ]),
+            );
+        })();
+
+        return {
+            name: obj.name,
+            target,
+            kind,
+            value,
+            validate,
+            exclusive: exclusive ?? false,
+        };
+    };
+
+    const get_exclusive =
+        (key: string) =>
+        (value: Metadata | undefined): boolean | string[] => {
+            if (value === undefined) return false;
+            else if (
+                value.size() === 1 &&
+                value.constants.length === 1 &&
+                value.constants[0]!.type === "boolean" &&
+                value.constants[0]!.values.length === 1
+            )
+                return value.constants[0]!.values[0]! as boolean;
+            else if (
+                value.size() === 1 &&
+                value.tuples.length === 1 &&
+                value.tuples[0]!.type.elements.every(
+                    (elem) =>
+                        elem.size() === 1 &&
+                        elem.constants.length === 1 &&
+                        elem.constants[0]!.type === "string" &&
+                        elem.constants[0]!.values.length === 1,
+                )
+            )
+                return value.tuples[0]!.type.elements.map(
+                    (elem) => elem.constants[0]!.values[0]! as string,
+                );
+            throw error(key)(
+                "must a boolean literal type or a tuple of string literal types.",
+            );
+        };
+}
+
+interface ITypeTag {
+    name: string;
+    target: "bigint" | "number" | "string" | "array";
+    kind: string;
+    value?: boolean | bigint | number | string;
+    validate: Record<string, string>;
+    exclusive: boolean | string[];
+}
+
+const FIELDS = ["target", "kind", "value", "validate"];
+
+const error = (property: string | null) => (msg: string) =>
+    new Error(
+        `Error on typia.MetadataFactory.analyze(): the property '${
+            property === null ? `["typia.tag"]` : `["typia.tag.${property}"]`
+        }' ${msg}.`,
+    );

package/src/factories/NumericRangeFactory.ts

@@ -0,0 +1,33 @@
+import ts from "typescript";
+
+import { ProtobufAtomic } from "../typings/ProtobufAtomic";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+
+export namespace NumericRangeFactory {
+    export const number =
+        (context: ts.TransformationContext) =>
+        (type: ProtobufAtomic.Numeric) =>
+        (input: ts.Expression): ts.Expression =>
+            ExpressionFactory.transpile(context)(NUMBER_TEXT[type])(input);
+
+    export const bigint =
+        (context: ts.TransformationContext) =>
+        (type: ProtobufAtomic.BigNumeric) =>
+        (input: ts.Expression): ts.Expression =>
+            ExpressionFactory.transpile(context)(BIGINT_TEXT[type])(input);
+}
+
+const NUMBER_TEXT = {
+    int32: `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`,
+    uint32: `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`,
+    int64: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`,
+    uint64: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`,
+    float: `-1.175494351e38 <= $input && $input <= 3.4028235e38`,
+    double: `true`,
+};
+
+const BIGINT_TEXT = {
+    int64: `true`,
+    uint64: `BigInt(0) <= $input`,
+};

package/src/factories/ProtobufFactory.ts

@@ -71,12 +71,28 @@ export namespace ProtobufFactory {
                 );
         }
         //----
+        // ATOMIC CASES
+        //----
+        else 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)
+                )
+                    throw notSupportedError({ method })(
+                        `${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 (
             meta.arrays.length &&
-            meta.arrays.some((array) => !!array.value.arrays.length)
+            meta.arrays.some((array) => !!array.type.value.arrays.length)
         )
             throw notSupportedError({ method })("two dimenstional array type");
         // CHILD OF ARRAY TYPE MUST BE REQUIRED
@@ -84,15 +100,15 @@ export namespace ProtobufFactory {
             meta.arrays.length &&
             meta.arrays.some(
                 (array) =>
-                    array.value.isRequired() === false ||
-                    array.value.nullable === true,
+                    array.type.value.isRequired() === false ||
+                    array.type.value.nullable === true,
             )
         )
             throw notSupportedError({ method })("optional type in array");
         // UNION IN ARRAY
         else if (
             meta.arrays.length &&
-            meta.arrays.some((a) => a.value.size() > 1)
+            meta.arrays.some((a) => a.type.value.size() > 1)
         )
             throw notSupportedError({ method })("union type in array");
         // DO DYNAMIC OBJECT IN ARRAY
@@ -100,9 +116,9 @@ export namespace ProtobufFactory {
             meta.arrays.length &&
             meta.arrays.some(
                 (a) =>
-                    a.value.maps.length ||
-                    (a.value.objects.length &&
-                        a.value.objects.some(
+                    a.type.value.maps.length ||
+                    (a.type.value.objects.length &&
+                        a.type.value.objects.some(
                             (o) => ProtobufUtil.isStaticObject(o) === false,
                         )),
             )
@@ -182,7 +198,7 @@ export namespace ProtobufFactory {
             meta.objects.some(
                 (obj) =>
                     isDynamicObject(obj) &&
-                    obj.properties.some((p) => p.value.isBinaryUnion()),
+                    obj.properties.some((p) => ProtobufUtil.isUnion(p.value)),
             )
         )
             throw notSupportedError({ method })(
@@ -191,18 +207,18 @@ export namespace ProtobufFactory {
         //----
         // MAP CASES
         //----
-        // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT STRING
+        // KEY TYPE ISUNION
         else if (
             meta.maps.length &&
-            meta.maps.some(
-                (m) =>
-                    m.key.isBinaryUnion() ||
-                    (m.key.atomics.find((v) => v === "string") === undefined &&
-                        m.key.constants.find((c) => c.type === "string") ===
-                            undefined),
-            )
+            meta.maps.some((m) => ProtobufUtil.isUnion(m.key))
+        )
+            throw notSupportedError({ method })("union key typed map");
+        // KEY TYPE IS NOT ATOMIC
+        else if (
+            meta.maps.length &&
+            meta.maps.some((m) => ProtobufUtil.getAtomics(m.key).length !== 1)
         )
-            throw notSupportedError({ method })("non-string key typed map");
+            throw notSupportedError({ method })("non-atomic key typed map");
         // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
         else if (
             meta.maps.length &&
@@ -225,7 +241,7 @@ export namespace ProtobufFactory {
         // UNION IN MAP
         else 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");
     };

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

@@ -1,11 +1,14 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 export const emend_metadata_atomics = (meta: Metadata) => {
     // ATOMICS
-    for (const type of meta.atomics) {
-        const index: number = meta.constants.findIndex((c) => c.type === type);
+    for (const a of meta.atomics) {
+        const index: number = meta.constants.findIndex(
+            (c) => c.type === a.type,
+        );
         if (index !== -1) meta.constants.splice(index, 1);
     }
 
@@ -18,8 +21,12 @@ export const emend_metadata_atomics = (meta: Metadata) => {
             meta.constants.splice(index, 1);
             ArrayUtil.take(
                 meta.atomics,
-                (type) => type === "boolean",
-                () => "boolean",
+                (a) => a.type === "boolean",
+                () =>
+                    MetadataAtomic.create({
+                        type: "boolean" as const,
+                        tags: [],
+                    }),
             );
         }
     }
@@ -27,7 +34,7 @@ export const emend_metadata_atomics = (meta: Metadata) => {
     // TEMPLATE
     if (
         meta.templates.length &&
-        meta.atomics.find((type) => type === "string") !== undefined
+        meta.atomics.find((a) => a.type === "string") !== undefined
     )
         meta.templates.splice(0, meta.templates.length);
 };

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

@@ -7,7 +7,6 @@ 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 =
@@ -31,10 +30,5 @@ export const emplace_metadata_alias =
             true,
         );
         closure(value);
-        alias.tags.push(
-            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
-                () => alias.name,
-            ),
-        );
         return alias;
     };

package/src/factories/internal/metadata/{emplace_metadata_array.ts → emplace_metadata_array_type.ts}

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -9,11 +9,11 @@ import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
-export const emplace_metadata_array =
+export const emplace_metadata_array_type =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataArray => {
+    (type: ts.Type, nullable: boolean): MetadataArrayType => {
         // CHECK EXISTENCE
         const [array, newbie, setValue] = collection.emplaceArray(
             checker,

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

@@ -61,7 +61,6 @@ export const emplace_metadata_object =
                     value,
                     description,
                     jsDocTags,
-                    tags: [],
                 });
                 obj.properties.push(property);
                 return property;

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

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { Writable } from "../../../typings/Writable";
 
@@ -15,7 +15,7 @@ export const emplace_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+    (type: ts.TupleType, nullable: boolean): MetadataTupleType => {
         // CHECK EXISTENCE
         const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
         ArrayUtil.add(tuple.nullables, nullable);

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

@@ -2,12 +2,13 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_array } from "./emplace_metadata_array";
+import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
 
 export const iterate_metadata_array =
     (checker: ts.TypeChecker) =>
@@ -16,9 +17,16 @@ export const iterate_metadata_array =
     (meta: Metadata, type: ts.Type): boolean => {
         if (!checker.isArrayType(type)) return false;
 
-        const array: MetadataArray = emplace_metadata_array(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.arrays, array, (elem) => elem.name === array.name);
+        const arrayType: MetadataArrayType = emplace_metadata_array_type(
+            checker,
+        )(options)(collection)(type, meta.nullable);
+        ArrayUtil.add(
+            meta.arrays,
+            MetadataArray.create({
+                type: arrayType,
+                tags: [],
+            }),
+            (elem) => elem.type.name === arrayType.name,
+        );
         return true;
     };

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

@@ -1,8 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../../typings/Atomic";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -19,7 +18,11 @@ export const iterate_metadata_atomic = (
     const filter = same(type);
     const check = (info: IAtomicInfo) => {
         if (filter(info.atomic) || filter(info.literal)) {
-            ArrayUtil.add(meta.atomics, info.name);
+            ArrayUtil.add(
+                meta.atomics,
+                MetadataAtomic.create({ type: info.name, tags: [] }),
+                (x, y) => x.type === y.type,
+            );
             return true;
         }
         return false;
@@ -53,7 +56,7 @@ const ATOMICS: IAtomicInfo[] = [
 ];
 
 interface IAtomicInfo {
-    name: Atomic.Literal;
+    name: "boolean" | "number" | "bigint" | "string";
     atomic: ts.TypeFlags;
     literal: ts.TypeFlags;
 }