typia 3.5.0-dev.20230107 → 3.5.0-dev.20230124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "3.5.0-dev.20230107",
+  "version": "3.5.0-dev.20230124",
   "description": "Runtime type checkers and 5x faster JSON.stringify() function",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/factories/internal/protocols/ProtocolMetadataUtil.ts

@@ -78,4 +78,24 @@ export namespace ProtocolMetadataUtil {
             jsDocTags: [],
         });
     }
+
+    export function array(meta: Metadata): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            atomics: [],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [meta],
+            tuples: [],
+            objects: [],
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+    }
 }

package/src/factories/internal/protocols/iterate_protocol_map.ts

@@ -1,18 +1,23 @@
 import { Metadata } from "../../../metadata/Metadata";
 import { MetadataObject } from "../../../metadata/MetadataObject";
 
+import { IProtocolMap } from "../../../messages/IProtocolMap";
 import { IProtocolMessage } from "../../../messages/IProtocolMessage";
 import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
 import { emplace_protocol_object } from "./emplace_protocol_object";
 import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
 import { iterate_protocol_constant } from "./iterate_protocol_constant";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
 
 export const iterate_protocol_map =
     (container: "Object" | "Map") =>
     (dict: Map<string, IProtocolMessage>) =>
     (key: Metadata) =>
-    (value: Metadata) =>
-        `map<${getKeyName(key)}, ${getValueName(container)(dict)(value)}>`;
+    (value: Metadata): IProtocolMap => ({
+        type: "map",
+        key: getKeyName(key),
+        value: getValueName(container)(dict)(value),
+    });
 
 const getKeyName = (meta: Metadata) => {
     for (const atomic of meta.atomics)
@@ -26,7 +31,8 @@ const getValueName =
     (container: "Object" | "Map") =>
     (dict: Map<string, IProtocolMessage>) =>
     (meta: Metadata) => {
-        if (ProtocolMetadataUtil.standalone(meta)) return meta.getName();
+        if (ProtocolMetadataUtil.standalone(meta))
+            return iterate_protocol_metadata(dict)(meta)([]).oneOf[0]!.type;
 
         const obj: MetadataObject = ProtocolMetadataUtil.object(
             `${container}.Value<${meta.getName()}>`,

package/src/factories/internal/protocols/iterate_protocol_metadata.ts

@@ -1,6 +1,7 @@
 import { IMetadataTag } from "../../../metadata/IMetadataTag";
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProtocolMap } from "../../../messages/IProtocolMap";
 import { IProtocolMessage } from "../../../messages/IProtocolMessage";
 import { IProtocolProperty } from "../../../messages/IProtocolProperty";
 import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
@@ -18,7 +19,7 @@ export const iterate_protocol_metadata =
         const required: boolean = meta.required && !meta.nullable;
         const oneOf: IProtocolProperty.IOneOf[] = [];
 
-        const add = (type: string) => {
+        const add = (type: string | IProtocolMap) => {
             if (oneOf.some((one) => one.type === type)) return;
             oneOf.push({
                 type,
@@ -31,7 +32,11 @@ export const iterate_protocol_metadata =
                 meta.arrays.length === 1
                     ? (["Array", meta.arrays[0]!] as const)
                     : (["Set", meta.sets[0]!] as const);
-            add(iterate_protocol_repeated(container)(true)(dict)(child)(tags));
+            add(
+                iterate_protocol_repeated(container)(true, true)(dict)(child)(
+                    tags,
+                ),
+            );
             return {
                 required,
                 oneOf,
@@ -61,9 +66,17 @@ export const iterate_protocol_metadata =
         for (const tuple of meta.tuples)
             add(iterate_protocol_tuple(dict)(tuple));
         for (const array of meta.arrays)
-            add(iterate_protocol_repeated("Array")(false)(dict)(array)(tags));
+            add(
+                iterate_protocol_repeated("Array")(false, meta.bucket() === 1)(
+                    dict,
+                )(array)(tags),
+            );
         for (const set of meta.sets)
-            add(iterate_protocol_repeated("Set")(false)(dict)(set)(tags));
+            add(
+                iterate_protocol_repeated("Set")(false, meta.bucket() === 1)(
+                    dict,
+                )(set)(tags),
+            );
         for (const map of meta.maps)
             add(iterate_protocol_map("Map")(dict)(map.key)(map.value));
 

package/src/factories/internal/protocols/iterate_protocol_repeated.ts

@@ -2,24 +2,33 @@ import { IMetadataTag } from "../../../metadata/IMetadataTag";
 import { Metadata } from "../../../metadata/Metadata";
 import { MetadataObject } from "../../../metadata/MetadataObject";
 
+import { IProtocolMap } from "../../../messages/IProtocolMap";
 import { IProtocolMessage } from "../../../messages/IProtocolMessage";
 import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
 import { emplace_protocol_object } from "./emplace_protocol_object";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
 
 export const iterate_protocol_repeated =
     (container: "Array" | "Set") =>
-    (sole: boolean) =>
+    (sole: boolean, bucket: boolean) =>
     (dict: Map<string, IProtocolMessage>) =>
     (meta: Metadata) =>
-    (tags: IMetadataTag[]): string => {
+    (tags: IMetadataTag[]): string | IProtocolMap => {
         sole &&= ProtocolMetadataUtil.standalone(meta);
-        if (sole === true) return meta.getName();
+        if (sole === true)
+            return iterate_protocol_metadata(dict)(meta)(tags).oneOf[0]!.type;
 
         const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `${container}.Element<${meta.getName()}>`,
+            `${container}.${bucket ? "Element" : "Wrapper"}<${meta.getName()}>`,
             dict.size,
         );
-        obj.properties.push(ProtocolMetadataUtil.property("value", meta, tags));
+        obj.properties.push(
+            ProtocolMetadataUtil.property(
+                "value",
+                bucket ? meta : ProtocolMetadataUtil.array(meta),
+                tags,
+            ),
+        );
         emplace_protocol_object(dict)(obj);
         return obj.name;
     };

package/src/messages/IProtocolMap.ts

@@ -0,0 +1,5 @@
+export interface IProtocolMap {
+    type: "map";
+    key: string;
+    value: string | IProtocolMap;
+}

package/src/messages/IProtocolProperty.ts

@@ -1,3 +1,5 @@
+import { IProtocolMap } from "./IProtocolMap";
+
 export interface IProtocolProperty {
     key: string;
     oneOf: IProtocolProperty.IOneOf[];
@@ -6,6 +8,6 @@ export interface IProtocolProperty {
 }
 export namespace IProtocolProperty {
     export interface IOneOf {
-        type: string;
+        type: string | IProtocolMap;
     }
 }

package/src/metadata/Metadata.ts

@@ -1,6 +1,8 @@
 import { Atomic } from "../typings/Atomic";
 import { ClassProperties } from "../typings/ClassProperties";
 
+import { ArrayUtil } from "../utils/ArrayUtil";
+
 import { IMetadata } from "./IMetadata";
 import { IMetadataObject } from "./IMetadataObject";
 import { MetadataConstant } from "./MetadataConstant";
@@ -417,6 +419,58 @@ export namespace Metadata {
         // SUCCESS
         return true;
     }
+
+    export function merge(x: Metadata, y: Metadata): Metadata {
+        const output: Metadata = Metadata.create({
+            any: x.any || y.any,
+            nullable: x.nullable || y.nullable,
+            required: x.required && y.required,
+            functional: x.functional || y.functional,
+
+            resolved:
+                x.resolved !== null && y.resolved !== null
+                    ? merge(x.resolved, y.resolved)
+                    : x.resolved || y.resolved,
+            atomics: [...new Set([...x.atomics, ...y.atomics])],
+            constants: [...x.constants],
+            templates: x.templates.slice(),
+
+            rest:
+                x.rest !== null && y.rest !== null
+                    ? merge(x.rest, y.rest)
+                    : x.rest ?? y.rest,
+            arrays: x.arrays.slice(),
+            tuples: x.tuples.slice(),
+            objects: x.objects.slice(),
+
+            natives: [...new Set([...x.natives, ...y.natives])],
+            sets: x.sets.slice(),
+            maps: x.maps.slice(),
+        });
+        for (const constant of y.constants) {
+            const target: MetadataConstant = ArrayUtil.take(
+                output.constants,
+                (elem) => elem.type === constant.type,
+                () => ({
+                    type: constant.type,
+                    values: [],
+                }),
+            );
+            for (const value of constant.values)
+                ArrayUtil.add(target.values, value);
+        }
+        for (const array of y.arrays)
+            ArrayUtil.set(output.arrays, array, (elem) => elem.getName());
+        for (const obj of y.objects)
+            ArrayUtil.set(output.objects, obj, (elem) => elem.name);
+
+        if (x.rest !== null)
+            ArrayUtil.set(output.arrays, x.rest, (elem) => elem.getName());
+        if (y.rest !== null)
+            ArrayUtil.set(output.arrays, y.rest, (elem) => elem.getName());
+
+        return output;
+    }
 }
 
 function getName(metadata: Metadata): string {

package/src/programmers/MessageProgrammer.ts

@@ -11,6 +11,7 @@ import { Escaper } from "../utils/Escaper";
 import { MapUtil } from "../utils/MapUtil";
 import { NameEncoder } from "../utils/NameEncoder";
 
+import { IProtocolMap } from "../messages/IProtocolMap";
 import { IProtocolMessage } from "../messages/IProtocolMessage";
 
 export namespace MessageProgrammer {
@@ -53,7 +54,7 @@ export namespace MessageProgrammer {
                             TAB,
                             property.required ? "" : "optional ",
                             property.repeated ? "repeated " : "",
-                            NameEncoder.encode(property.oneOf[0]!.type) + " ",
+                            getTypeName(property.oneOf[0]!.type) + " ",
                             Escaper.variable(property.key)
                                 ? property.key
                                 : `v${index + 1}`,
@@ -65,7 +66,7 @@ export namespace MessageProgrammer {
                         property.oneOf
                             .map(
                                 (o, i) =>
-                                    `${TAB}${TAB}${NameEncoder.encode(
+                                    `${TAB}${TAB}${getTypeName(
                                         o.type,
                                     )} o${i} = ${index++};`,
                             )
@@ -105,6 +106,12 @@ export namespace MessageProgrammer {
                 if (i === accessors.length - 1) hierarchy.message = message;
             });
         };
+
+    function getTypeName(type: string | IProtocolMap): string {
+        return typeof type === "string"
+            ? NameEncoder.encode(type)
+            : `map<${type.key}, ${getTypeName(type.value)}>`;
+    }
 }
 
 interface Hierarchy {

package/src/programmers/internal/application_array.ts

@@ -11,6 +11,7 @@ import { application_schema } from "./application_schema";
 export const application_array =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
+    (tuple?: IJsonSchema.ITuple) =>
     (
         metadata: Metadata,
         nullable: boolean,
@@ -24,6 +25,7 @@ export const application_array =
                 attribute,
             ),
             nullable,
+            "x-typia-tuple": tuple,
             ...attribute,
         };
 

package/src/programmers/internal/application_object.ts

@@ -1,6 +1,7 @@
 import { CommentFactory } from "../../factories/CommentFactory";
 
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { Metadata } from "../../metadata/Metadata";
 import { MetadataObject } from "../../metadata/MetadataObject";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 
@@ -24,8 +25,10 @@ export const application_object =
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
-        const patternProperties: Record<string, any> = {};
-        const additionalProperties: IJsonSchema[] = [];
+        const extraMeta: ISuperfluous = {
+            patternProperties: {},
+            additionalProperties: undefined,
+        };
         const required: string[] = [];
 
         for (const property of obj.properties) {
@@ -38,7 +41,7 @@ export const application_object =
                 continue;
 
             const key: string | null = property.key.getSoleLiteral();
-            const value: IJsonSchema | null = application_schema(options)(
+            const schema: IJsonSchema | null = application_schema(options)(
                 components,
             )(true)(property.value, {
                 deprecated:
@@ -62,21 +65,35 @@ export const application_object =
                 "x-typia-required": property.value.required,
             });
 
-            if (value === null) continue;
+            if (schema === null) continue;
             else if (key !== null) {
-                properties[key] = value;
+                properties[key] = schema;
                 if (property.value.required === true) required.push(key);
             } else {
                 const pattern: string = metadata_to_pattern(true)(property.key);
-                if (
-                    options.purpose === "swagger" ||
-                    pattern === PatternUtil.STRING
-                )
-                    additionalProperties.push(value);
-                else patternProperties[pattern] = value;
+                if (pattern === PatternUtil.STRING)
+                    extraMeta.additionalProperties = [property.value, schema];
+                else
+                    extraMeta.patternProperties[pattern] = [
+                        property.value,
+                        schema,
+                    ];
             }
         }
 
+        const extraProps = {
+            additionalProperties: extraMeta.additionalProperties?.[1],
+            patternProperties: (() => {
+                if (Object.keys(extraMeta.patternProperties).length === 0)
+                    return undefined;
+                const output: Record<string, IJsonSchema> = {};
+                for (const [key, value] of Object.entries(
+                    extraMeta.patternProperties,
+                ))
+                    output[key] = value[1];
+                return output;
+            })(),
+        };
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
@@ -86,18 +103,51 @@ export const application_object =
                 (options.purpose === "ajv" && obj.recursive) || undefined,
             type: "object",
             properties,
-            patternProperties: Object.keys(patternProperties).length
-                ? patternProperties
-                : undefined,
-            additionalProperties: additionalProperties.length
-                ? additionalProperties.length === 1
-                    ? additionalProperties[0]
-                    : { oneOf: additionalProperties }
-                : undefined,
             nullable,
             required: required.length ? required : undefined,
             description: obj.description,
-            "x-typia_jsDocTags": obj.jsDocTags,
+            "x-typia-jsDocTags": obj.jsDocTags,
+            ...(options.purpose === "ajv"
+                ? extraProps
+                : {
+                      // swagger can't express patternProperties
+                      "x-typia-additionalProperties":
+                          extraProps.additionalProperties,
+                      "x-typia-patternProperties": extraProps.patternProperties,
+                      additionalProperties:
+                          join(options)(components)(extraMeta),
+                  }),
         };
         components.schemas[id] = schema;
     };
+
+const join =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (extra: ISuperfluous): IJsonSchema | undefined => {
+        // LIST UP METADATA
+        const elements: [Metadata, IJsonSchema][] = Object.values(
+            extra.patternProperties || {},
+        );
+        if (extra.additionalProperties)
+            elements.push(extra.additionalProperties);
+
+        // SHORT RETURN
+        if (elements.length === 0) return undefined;
+        else if (elements.length === 1) return elements[0]![1]!;
+
+        // MERGE METADATA AND GENERATE VULNERABLE SCHEMA
+        const meta: Metadata = elements
+            .map((tuple) => tuple[0])
+            .reduce((x, y) => Metadata.merge(x, y));
+        return (
+            application_schema(options)(components)(true)(meta, {
+                "x-typia-required": false,
+            }) ?? undefined
+        );
+    };
+
+interface ISuperfluous {
+    additionalProperties?: [Metadata, IJsonSchema];
+    patternProperties: Record<string, [Metadata, IJsonSchema]>;
+}

package/src/programmers/internal/application_schema.ts

@@ -1,9 +1,7 @@
 import { Metadata } from "../../metadata/Metadata";
-import { MetadataConstant } from "../../metadata/MetadataConstant";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
 import { NameEncoder } from "../../utils/NameEncoder";
 
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
@@ -75,7 +73,7 @@ export const application_schema =
         // ARRAY
         for (const schema of meta.arrays.values())
             union.push(
-                application_array(options)(components)(
+                application_array(options)(components)()(
                     schema,
                     meta.nullable,
                     attribute,
@@ -83,36 +81,33 @@ export const application_schema =
             );
 
         // TUPLE
-        for (const items of meta.tuples)
-            if (
+        for (const items of meta.tuples) {
+            const tuple: IJsonSchema.ITuple = application_tuple(options)(
+                components,
+            )(items, meta.nullable, attribute);
+            if (options.purpose === "swagger" && items.length === 0)
+                throw new Error(
+                    "Error on typia.application(): swagger does not support zero length tuple type.",
+                );
+            else if (
                 options.purpose === "ajv" &&
-                items.every((i) => i.rest === null)
+                !items[items.length - 1]?.rest
             )
-                union.push(
-                    application_tuple(options)(components)(
-                        items,
-                        meta.nullable,
-                        attribute,
-                    ),
-                );
+                union.push(tuple);
             else {
-                if (items.length === 0)
-                    throw new Error(
-                        "Error on typia.application(): swagger does not support zero length tuple type.",
-                    );
-
                 // SWAGGER DOES NOT SUPPORT TUPLE TYPE YET
                 const merged: Metadata = items.reduce((x, y) =>
-                    merge_metadata(x, y),
+                    Metadata.merge(x, y),
                 );
                 union.push(
-                    application_array(options)(components)(
+                    application_array(options)(components)(tuple)(
                         merged,
                         merged?.nullable || false,
                         attribute,
                     ),
                 );
             }
+        }
 
         // NATIVES
         for (const native of meta.natives)
@@ -180,57 +175,4 @@ const recursive = (
     ...attribute,
 });
 
-/**
- * @internal
- * @todo: not perfect
- */
-function merge_metadata(x: Metadata, y: Metadata): Metadata {
-    const output: Metadata = Metadata.create({
-        any: x.any || y.any,
-        nullable: x.nullable || y.nullable,
-        required: x.required && y.required,
-        functional: x.functional || y.functional,
-
-        resolved:
-            x.resolved !== null && y.resolved !== null
-                ? merge_metadata(x.resolved, y.resolved)
-                : x.resolved || y.resolved,
-        atomics: [...new Set([...x.atomics, ...y.atomics])],
-        constants: [...x.constants],
-        templates: x.templates.slice(),
-
-        rest: null,
-        arrays: x.arrays.slice(),
-        tuples: x.tuples.slice(),
-        objects: x.objects.slice(),
-
-        natives: [...new Set([...x.natives, ...y.natives])],
-        sets: x.sets.slice(),
-        maps: x.maps.slice(),
-    });
-    for (const constant of y.constants) {
-        const target: MetadataConstant = ArrayUtil.take(
-            output.constants,
-            (elem) => elem.type === constant.type,
-            () => ({
-                type: constant.type,
-                values: [],
-            }),
-        );
-        for (const value of constant.values)
-            ArrayUtil.add(target.values, value);
-    }
-    for (const array of y.arrays)
-        ArrayUtil.set(output.arrays, array, (elem) => elem.getName());
-    for (const obj of y.objects)
-        ArrayUtil.set(output.objects, obj, (elem) => elem.name);
-
-    if (x.rest !== null)
-        ArrayUtil.set(output.arrays, x.rest, (elem) => elem.getName());
-    if (y.rest !== null)
-        ArrayUtil.set(output.arrays, y.rest, (elem) => elem.getName());
-
-    return output;
-}
-
 const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/application_tuple.ts

@@ -17,8 +17,12 @@ export const application_tuple =
         attribute: IJsonSchema.IAttribute,
     ): IJsonSchema.ITuple => ({
         type: "array",
-        items: items.map((meta) =>
-            application_schema(options)(components)(false)(meta, attribute),
+        items: items.map((meta, i) =>
+            application_schema(options)(components)(false)(meta.rest ?? meta, {
+                ...attribute,
+                "x-typia-rest":
+                    i === items.length - 1 ? meta.rest !== null : undefined,
+            }),
         ),
         nullable,
         ...attribute,

package/src/schemas/IJsonComponents.ts

@@ -8,6 +8,8 @@ export interface IJsonComponents {
 export namespace IJsonComponents {
     export interface IObject {
         $id?: string;
+        $recursiveAnchor?: boolean;
+
         type: "object";
         nullable: boolean;
 
@@ -17,8 +19,8 @@ export namespace IJsonComponents {
 
         required?: string[];
         description?: string;
-        "x-typia_jsDocTags"?: IJsDocTagInfo[];
-
-        $recursiveAnchor?: boolean;
+        "x-typia-jsDocTags"?: IJsDocTagInfo[];
+        "x-typia-patternProperties"?: Record<string, IJsonSchema>;
+        "x-typia-additionalProperties"?: IJsonSchema;
     }
 }

package/src/schemas/IJsonSchema.ts

@@ -53,6 +53,7 @@ export namespace IJsonSchema {
         items: IJsonSchema;
         minItems?: number;
         maxItems?: number;
+        "x-typia-tuple"?: ITuple;
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];
@@ -86,5 +87,6 @@ export namespace IJsonSchema {
         "x-typia-metaTags"?: IMetadataTag[];
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
+        "x-typia-rest"?: boolean;
     }
 }