typia 3.5.0-dev.20230107 → 3.5.0-dev.20230125

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

@@ -3,6 +3,8 @@ import { Metadata } from "../../../metadata/Metadata";
 import { MetadataObject } from "../../../metadata/MetadataObject";
 import { MetadataProperty } from "../../../metadata/MetadataProperty";
 
+import { Atomic } from "../../../typings/Atomic";
+
 export namespace ProtocolMetadataUtil {
     export function size(meta: Metadata): number {
         return (
@@ -78,4 +80,84 @@ 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: [],
+        });
+    }
+
+    export function atomic(type: Atomic.Literal): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            atomics: [type],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [],
+            tuples: [],
+            objects: [],
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+    }
+
+    export function reference(obj: MetadataObject): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            atomics: [],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [],
+            tuples: [],
+            objects: [obj],
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+    }
+
+    export function map(elem: Metadata.Entry): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            atomics: [],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [],
+            tuples: [],
+            objects: [],
+            natives: [],
+            sets: [],
+            maps: [elem],
+        });
+    }
 }

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

@@ -8,9 +8,7 @@ export const emplace_protocol_object =
         if (dict.has(object.name)) return;
 
         const regular = object.properties.filter((p) => p.key.isSoleLiteral());
-        const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
-
-        if (!regular.length || dynamic.length) return;
+        // const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
 
         const output: IProtocolMessage = {
             name: object.name,

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

@@ -1,18 +1,39 @@
 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") =>
+    (sole: boolean) =>
     (dict: Map<string, IProtocolMessage>) =>
-    (key: Metadata) =>
-    (value: Metadata) =>
-        `map<${getKeyName(key)}, ${getValueName(container)(dict)(value)}>`;
+    (prop: Metadata.Entry): string | IProtocolMap => {
+        if (sole === true)
+            return {
+                type: "map",
+                key: getKeyName(prop.key),
+                value: getValueName(dict)(prop.value),
+            };
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            `Map.Wrapper<${prop.key.getName()}, ${prop.value.getName()}>`,
+            dict.size,
+        );
+        obj.properties.push(
+            ProtocolMetadataUtil.property(
+                "value",
+                ProtocolMetadataUtil.map(prop),
+                [],
+            ),
+        );
+        emplace_protocol_object(dict)(obj);
+        return obj.name;
+    };
 
 const getKeyName = (meta: Metadata) => {
     for (const atomic of meta.atomics)
@@ -23,13 +44,12 @@ const getKeyName = (meta: Metadata) => {
 };
 
 const getValueName =
-    (container: "Object" | "Map") =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata) => {
-        if (ProtocolMetadataUtil.standalone(meta)) return meta.getName();
+    (dict: Map<string, IProtocolMessage>) => (meta: Metadata) => {
+        if (ProtocolMetadataUtil.standalone(meta))
+            return iterate_protocol_metadata(dict)(meta)([]).oneOf[0]!.type;
 
         const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `${container}.Value<${meta.getName()}>`,
+            `Map.Value<${meta.getName()}>`,
             dict.size,
         );
         obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));

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

@@ -1,12 +1,15 @@
 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";
 import { iterate_protocol_constant } from "./iterate_protocol_constant";
 import { iterate_protocol_map } from "./iterate_protocol_map";
 import { iterate_protocol_native } from "./iterate_protocol_native";
+import { iterate_protocol_never } from "./iterate_protocol_never";
+import { iterate_protocol_object } from "./iterate_protocol_object";
 import { iterate_protocol_repeated } from "./iterate_protocol_repeated";
 import { iterate_protocol_tuple } from "./iterate_protocol_tuple";
 
@@ -15,10 +18,20 @@ export const iterate_protocol_metadata =
     (meta: Metadata) =>
     (tags: IMetadataTag[]): Omit<IProtocolProperty, "key"> => {
         // PREPARE ASSETS
-        const required: boolean = meta.required && !meta.nullable;
-        const oneOf: IProtocolProperty.IOneOf[] = [];
+        const sole: boolean = meta.size() === 1;
+        const bucket: boolean = sole && meta.bucket() === 1;
+        const required: boolean =
+            (meta.required && !meta.nullable) ||
+            (sole &&
+                (meta.arrays.length === 1 ||
+                    meta.sets.length === 1 ||
+                    meta.maps.length === 1 ||
+                    (meta.objects.length === 1 &&
+                        meta.objects[0]!.properties.length === 1 &&
+                        !meta.objects[0]!.properties[0]?.key.isSoleLiteral())));
 
-        const add = (type: string) => {
+        const oneOf: IProtocolProperty.IOneOf[] = [];
+        const add = (type: string | IProtocolMap) => {
             if (oneOf.some((one) => one.type === type)) return;
             oneOf.push({
                 type,
@@ -26,12 +39,16 @@ export const iterate_protocol_metadata =
         };
 
         // WHEN SINGULAR ARRAY TYPE
-        if (meta.size() === 1 && meta.arrays.length + meta.sets.length === 1) {
+        if (sole && meta.arrays.length + meta.sets.length === 1) {
             const [container, child] =
                 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,
@@ -45,27 +62,30 @@ export const iterate_protocol_metadata =
         for (const constant of meta.constants)
             add(iterate_protocol_constant(constant));
         if (meta.templates.length) add("string");
+        if (meta.size() === 0) add(iterate_protocol_never());
 
-        // INSTANCE TYPES
+        // OBJECT TYPES
         for (const obj of meta.objects)
-            if (obj.properties.some((p) => !p.key.isSoleLiteral())) {
-                for (const prop of obj.properties)
-                    add(
-                        iterate_protocol_map("Object")(dict)(prop.key)(
-                            prop.value,
-                        ),
-                    );
-            } else add(obj.name);
+            add(iterate_protocol_object(sole)(dict)(obj));
+        for (const map of meta.maps) add(iterate_protocol_map(sole)(dict)(map));
         for (const native of meta.natives)
             add(iterate_protocol_native(dict)(native));
+
+        // ARRAY TYPES
         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, bucket)(dict)(array)(
+                    tags,
+                ),
+            );
         for (const set of meta.sets)
-            add(iterate_protocol_repeated("Set")(false)(dict)(set)(tags));
-        for (const map of meta.maps)
-            add(iterate_protocol_map("Map")(dict)(map.key)(map.value));
+            add(
+                iterate_protocol_repeated("Set")(false, bucket)(dict)(set)(
+                    tags,
+                ),
+            );
 
         // RETURNS
         return {

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

@@ -0,0 +1 @@
+export const iterate_protocol_never = () => "uint32";

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

@@ -0,0 +1,110 @@
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { Atomic } from "../../../typings/Atomic";
+
+import { MapUtil } from "../../../utils/MapUtil";
+
+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_object =
+    (sole: boolean) =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (obj: MetadataObject): string | IProtocolMap => {
+        // ONLY REGULAR PROPERTIES
+        const statics: MetadataProperty[] = obj.properties.filter(filter(true));
+        const dynamics: Metadata.Entry[] = aggregate(
+            obj.properties.filter(filter(false)),
+        );
+        if (dynamics.length === 0) return obj.name;
+
+        const regular: MetadataObject | undefined = statics.length
+            ? (() => {
+                  const r: MetadataObject = ProtocolMetadataUtil.object(
+                      `${obj.name}.__Regular`,
+                      dict.size,
+                  );
+                  r.properties.push(...statics);
+                  emplace_protocol_object(dict)(r);
+                  return r;
+              })()
+            : undefined;
+
+        // ONLY ONE TYPED DYNAMIC PROPERTY EXISTS
+        if (regular === undefined && dynamics.length === 1 && sole === true) {
+            const { key, value } = dynamics[0]!;
+            return {
+                type: "map",
+                key: key.getName(),
+                value: ProtocolMetadataUtil.standalone(value)
+                    ? iterate_protocol_metadata(dict)(value)([]).oneOf[0]!.type
+                    : (() => {
+                          const wrapper = ProtocolMetadataUtil.object(
+                              `${obj.name}.__Wrapper`,
+                              dict.size,
+                          );
+                          wrapper.properties.push(
+                              ProtocolMetadataUtil.property("value", value, []),
+                          );
+                          emplace_protocol_object(dict)(wrapper);
+                          return wrapper.name;
+                      })(),
+            };
+        }
+
+        // DO WRAP
+        const wrapper: MetadataObject = ProtocolMetadataUtil.object(
+            `${obj.name}.__Wrapper`,
+            dict.size,
+        );
+        if (regular !== undefined)
+            wrapper.properties.push(
+                ProtocolMetadataUtil.property(
+                    "regular",
+                    ProtocolMetadataUtil.reference(regular),
+                    [],
+                ),
+            );
+        wrapper.properties.push(
+            ...dynamics.map((map, i) =>
+                ProtocolMetadataUtil.property(
+                    `__map_${i}`,
+                    ProtocolMetadataUtil.map(map),
+                    [],
+                ),
+            ),
+        );
+        emplace_protocol_object(dict)(wrapper);
+        return wrapper.name;
+    };
+
+const filter = (regular: boolean) => (prop: MetadataProperty) =>
+    regular === prop.key.isSoleLiteral();
+
+const aggregate = (properties: MetadataProperty[]): Metadata.Entry[] => {
+    const unique: Map<Atomic.Literal, MetadataProperty[]> = new Map();
+    for (const prop of properties) {
+        if (prop.key.templates)
+            MapUtil.take(unique, "string", () => []).push(prop);
+        for (const type of prop.key.atomics)
+            MapUtil.take(unique, type, () => []).push(prop);
+        for (const { type } of prop.key.constants)
+            MapUtil.take(unique, type, () => []).push(prop);
+    }
+    const output: Metadata.Entry[] = [];
+    for (const [key, properties] of unique) {
+        const value: Metadata = properties
+            .map((x) => x.value)
+            .reduce((x, y) => Metadata.merge(x, y));
+        output.push({
+            key: ProtocolMetadataUtil.atomic(key),
+            value,
+        });
+    }
+    return output;
+};

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/factories/internal/protocols/iterate_protocol_tuple.ts

@@ -17,7 +17,11 @@ export const iterate_protocol_tuple =
         );
         obj.properties.push(
             ...tuple.map((value, i) =>
-                ProtocolMetadataUtil.property(`v${i}`, value, []),
+                ProtocolMetadataUtil.property(
+                    `v${i}`,
+                    value.rest ? ProtocolMetadataUtil.array(value.rest) : value,
+                    [],
+                ),
             ),
         );
         emplace_protocol_object(dict)(obj);

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 {
@@ -457,7 +511,8 @@ function getName(metadata: Metadata): string {
         elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
 
     // ARRAY
-    if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
+    if (metadata.rest !== null)
+        elements.push(`Rest<${metadata.rest.getName()}>`);
     for (const tuple of metadata.tuples)
         elements.push(`[${tuple.map((elem) => elem.getName()).join(", ")}]`);
     for (const array of metadata.arrays)

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 {
@@ -48,26 +49,29 @@ export namespace MessageProgrammer {
         if (message !== null)
             elements.push(
                 ...message.properties.map((property) => {
+                    const key: string =
+                        Escaper.variable(property.key) &&
+                        property.key.indexOf("$") === -1
+                            ? property.key
+                            : `v${index + 1}`;
                     if (property.oneOf.length === 1)
                         return [
                             TAB,
                             property.required ? "" : "optional ",
                             property.repeated ? "repeated " : "",
-                            NameEncoder.encode(property.oneOf[0]!.type) + " ",
-                            Escaper.variable(property.key)
-                                ? property.key
-                                : `v${index + 1}`,
+                            getTypeName(property.oneOf[0]!.type) + " ",
+                            key,
                             " = ",
                             `${index++};`,
                         ].join("");
                     return (
-                        `${TAB}oneof ${property.key} {\n` +
+                        `${TAB}oneof ${key} {\n` +
                         property.oneOf
                             .map(
                                 (o, i) =>
-                                    `${TAB}${TAB}${NameEncoder.encode(
+                                    `${TAB}${TAB}${getTypeName(
                                         o.type,
-                                    )} o${i} = ${index++};`,
+                                    )} ${key}_o${i} = ${index++};`,
                             )
                             .join("\n") +
                         `\n${TAB}}`
@@ -105,6 +109,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,
         };