typia 5.0.0-dev.20230805 → 5.0.0-dev.20230810

package/src/factories/ProtobufFactory.ts

@@ -0,0 +1,235 @@
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { IProtocolMessage } from "../schemas/protobuf/IProtocolMessage";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+import { emplace_protocol_object } from "./internal/protocols/emplace_protocol_object";
+import { iterate_protocol_main } from "./internal/protocols/iterate_protocol_main";
+
+export namespace ProtobufFactory {
+    export const metadata =
+        (method: string) =>
+        (checker: ts.TypeChecker) =>
+        (collection: MetadataCollection) =>
+        (type: ts.Type) => {
+            // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
+            const top: Metadata = MetadataFactory.analyze(checker)({
+                resolve: false,
+                constant: true,
+                absorb: true,
+                validate: validate(method),
+            })(collection)(type);
+
+            // TOP LEVEL TYPE MUST BE A SINGLE OBJECT
+            const onlyObject: boolean =
+                top.size() === 1 &&
+                top.objects.length === 1 &&
+                top.objects[0]!.properties.every((p) =>
+                    p.key.isSoleLiteral(),
+                ) &&
+                top.isRequired() === true &&
+                top.nullable === false;
+            if (onlyObject === false)
+                throw new Error(
+                    `${prefix(
+                        method,
+                    )} target type must be a sole and static object.`,
+                );
+
+            return top;
+        };
+
+    export const analyze =
+        (collection: MetadataCollection) =>
+        (dict: Map<string, IProtocolMessage>) =>
+        (meta: Metadata) => {
+            // EMPLACE OBJECTS
+            for (const obj of collection.objects())
+                emplace_protocol_object(dict)(obj);
+
+            // WHEN NOT OBJECT, WRAP IT INTO A FAKE MAIN OBJECT
+            iterate_protocol_main(dict)(meta);
+        };
+
+    const validate = (method: string) => (meta: Metadata) => {
+        //----
+        // NOT ALLOWED TYPES
+        //----
+        if (meta.any) throw notSupportedError({ method })("any type");
+        else if (meta.functional)
+            throw notSupportedError({ method })("functional type");
+        else if (meta.tuples.length)
+            throw notSupportedError({ method })("tuple type");
+        else if (meta.sets.length)
+            throw notSupportedError({ method })("Set type");
+        else if (
+            meta.arrays.length &&
+            meta.arrays.some((array) => !!array.value.arrays.length)
+        )
+            throw notSupportedError({ method })("two dimenstional array type");
+        //----
+        // SPECIAL CASES
+        //----
+        // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
+        else if (
+            meta.objects.length &&
+            meta.objects.some(
+                (obj) =>
+                    obj.properties.filter((p) => !p.key.isSoleLiteral())
+                        .length > 1,
+            )
+        )
+            throw notSupportedError({ method })(
+                "object type with multiple dynamic key typed properties. Keep only one.",
+            );
+        // STATIC AND DYNAMIC PROPERTIES ARE COMPATIBLE
+        else if (
+            meta.objects.length &&
+            meta.objects.some(
+                (obj) =>
+                    obj.properties.length &&
+                    obj.properties.some((p) => p.key.isSoleLiteral()) &&
+                    obj.properties.some((p) => !p.key.isSoleLiteral()),
+            )
+        )
+            throw notSupportedError({ method })(
+                "object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.",
+            );
+        // NATIVE TYPE, BUT NOT Uint8Array
+        else 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 })(
+                    banned[1] === null
+                        ? banned[0]
+                        : `${banned[0]}. Use ${banned[1]} instead.`,
+                );
+        }
+        // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT ATOMIC
+        else if (
+            meta.maps.length &&
+            meta.maps.some((m) => !is_atomic_key(m.key))
+        )
+            throw notSupportedError({ method })("");
+        //----
+        // UNION TYPES
+        //----
+        // UNION IN ARRAY
+        else if (
+            meta.arrays.length &&
+            meta.arrays.some((a) => a.value.size() > 1)
+        )
+            throw notSupportedError({ method })("union type in array");
+        // UNION WITH ARRAY
+        else if (meta.size() > 1 && meta.arrays.length)
+            throw notSupportedError({ method })("union type with array type");
+        // UNION WITH DYNAMIC OBJECT
+        else if (
+            meta.size() > 1 &&
+            meta.objects.length &&
+            isDynamicObject(meta.objects[0]!)
+        )
+            throw notSupportedError({ method })(
+                "union type with dynamic object type",
+            );
+        // UNION IN DYNAMIC PROPERTY VALUE
+        else if (
+            meta.objects.length &&
+            meta.objects.some(
+                (obj) =>
+                    isDynamicObject(obj) &&
+                    obj.properties.some((p) => isUnion(p.value)),
+            )
+        )
+            throw notSupportedError({ method })(
+                "union type in dynamic property",
+            );
+        // UNION WITH MAP
+        else if (meta.size() > 1 && meta.maps.length)
+            throw notSupportedError({ method })("union type with map type");
+        // UNION IN MAP
+        else if (meta.maps.length && meta.maps.some((m) => isUnion(m.value)))
+            throw notSupportedError({ method })("union type in map");
+    };
+
+    const is_atomic_key = (key: Metadata) => {
+        if (
+            key.required &&
+            key.nullable === false &&
+            key.functional === false &&
+            key.resolved === null &&
+            key.size() ===
+                key.atomics.length +
+                    key.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    key.templates.length
+        ) {
+            const set: Set<string> = new Set();
+            for (const atomic of key.atomics) set.add(atomic);
+            for (const constant of key.constants) set.add(constant.type);
+            if (key.templates.length) set.add("string");
+
+            return set.size === 1;
+        }
+        return false;
+    };
+}
+
+const prefix = (method: string) => `Error on typia.protobuf.${method}():`;
+
+const notSupportedError = (p: { method: string }) => (title: string) =>
+    new Error(
+        `${prefix(p.method)}: protocol buffer does not support ${title}.`,
+    );
+
+const isDynamicObject = (obj: MetadataObject): boolean => {
+    return (
+        obj.properties.length > 0 &&
+        obj.properties[0]!.key.isSoleLiteral() === false
+    );
+};
+
+const isUnion = (meta: Metadata): boolean => {
+    const count: number =
+        new Set([
+            ...meta.atomics,
+            ...meta.constants.map((c) => c.type),
+            ...(meta.templates.length ? ["string"] : []),
+        ]).size +
+        meta.arrays.length +
+        meta.tuples.length +
+        meta.natives.length +
+        meta.objects.length +
+        meta.maps.length;
+    return count > 1;
+};
+
+const BANNED_NATIVE_TYPES: Map<string, string | null> = new Map([
+    ["Date", "string"],
+    ["Boolean", "boolean"],
+    ["BigInt", "bigint"],
+    ["Number", "number"],
+    ["String", "string"],
+    ...[
+        "Buffer",
+        "Uint8ClampedArray",
+        "Uint16Array",
+        "Uint32Array",
+        "BigUint64Array",
+        "Int8Array",
+        "Int16Array",
+        "Int32Array",
+        "BigInt64Array",
+        "Float32Array",
+        "Float64Array",
+        "DataView",
+        "ArrayBuffer",
+        "SharedArrayBuffer",
+    ].map((name) => [name, "Uint8Array"] as const),
+]);

package/src/programmers/RandomProgrammer.ts

@@ -219,9 +219,7 @@ export namespace RandomProgrammer {
             const expressions: ts.Expression[] = [];
             if (meta.any)
                 expressions.push(
-                    ts.factory.createStringLiteral(
-                        "fucking any type exists...",
-                    ),
+                    ts.factory.createStringLiteral("any type used..."),
                 );
 
             // NULL COALESCING

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -145,6 +145,10 @@ export const stringify_dynamic_properties = (
         );
         statements.push(condition);
     }
+    statements.push(
+        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+    );
+
     return output();
 };
 

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,87 +1,71 @@
 import ts from "typescript";
 
 import { MetadataCollection } from "../../factories/MetadataCollection";
-import { ProtocolFactory } from "../../factories/ProtocolFactory";
+import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
+import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { IProtocolMap } from "../../schemas/protobuf/IProtocolMap";
-import { IProtocolMessage } from "../../schemas/protobuf/IProtocolMessage";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
 import { IProject } from "../../transformers/IProject";
 
-import { Escaper } from "../../utils/Escaper";
+import { Atomic } from "../../typings/Atomic";
+
 import { MapUtil } from "../../utils/MapUtil";
 import { NameEncoder } from "../../utils/NameEncoder";
 
 export namespace ProtobufMessageProgrammer {
-    export const generate =
+    export const write =
         ({ checker }: IProject) =>
         (type: ts.Type) => {
             // PARSE TARGET TYPE
             const collection: MetadataCollection = new MetadataCollection();
-            const metadata: Metadata =
-                ProtocolFactory.metadata(checker)(collection)(type);
-
-            // CONVERT TO PROTOCOL MESSAGES
-            const dict: Map<string, IProtocolMessage> = new Map();
-            ProtocolFactory.analyze(collection)(dict)(metadata);
+            ProtobufFactory.metadata("message")(checker)(collection)(type);
 
             // STRINGIFY
             const hierarchies: Map<string, Hierarchy> = new Map();
-            for (const msg of dict.values()) emplace(hierarchies)(msg);
+            for (const obj of collection.objects())
+                if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
 
             const content: string =
                 `syntax = "proto3";\n\n` +
                 [...hierarchies.values()]
-                    .map((hier) => stringify(hier))
+                    .map((hier) => write_hierarchy(hier))
                     .join("\n\n");
 
             // RETURNS
             return ts.factory.createStringLiteral(content);
         };
 
-    const stringify = (hierarchy: Hierarchy): string => {
-        const { key, message, children } = hierarchy;
-        let index: number = 1;
+    const emplace = (dict: Map<string, Hierarchy>) => (obj: MetadataObject) => {
+        const accessors: string[] = obj.name.split(".");
+        accessors.forEach((access, i) => {
+            const hierarchy: Hierarchy = MapUtil.take(dict)(access, () => ({
+                key: access,
+                object: null!,
+                children: new Map(),
+            }));
+            dict = hierarchy.children;
+            if (i === accessors.length - 1) hierarchy.object = obj;
+        });
+    };
 
-        const elements: string[] = [`message ${NameEncoder.encode(key)} {`];
-        if (message !== null)
+    const is_dynamic_object = (obj: MetadataObject): boolean =>
+        obj.properties.length === 1 &&
+        obj.properties[0]!.key.isSoleLiteral() === false;
+
+    const write_hierarchy = (hierarchy: Hierarchy): string => {
+        const elements: string[] = [
+            `message ${NameEncoder.encode(hierarchy.key)} {`,
+        ];
+        if (hierarchy.object !== null) {
+            const text: string = write_object(hierarchy.object);
+            elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
+        }
+        if (hierarchy.children.size)
             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 " : "",
-                            getTypeName(property.oneOf[0]!.type) + " ",
-                            key,
-                            " = ",
-                            `${index++};`,
-                        ].join("");
-                    return (
-                        `${TAB}oneof ${key} {\n` +
-                        property.oneOf
-                            .map(
-                                (o, i) =>
-                                    `${TAB}${TAB}${getTypeName(
-                                        o.type,
-                                    )} ${key}_o${i} = ${index++};`,
-                            )
-                            .join("\n") +
-                        `\n${TAB}}`
-                    );
-                }),
-            );
-        if (message !== null && children.size) elements.push("\n");
-        if (children.size)
-            elements.push(
-                [...children.values()]
-                    .map((child) => stringify(child))
+                [...hierarchy.children.values()]
+                    .map((child) => write_hierarchy(child))
                     .map((body) =>
                         body
                             .split("\n")
@@ -91,35 +75,92 @@ export namespace ProtobufMessageProgrammer {
                     .join("\n\n"),
             );
         elements.push("}");
-
         return elements.join("\n");
     };
 
-    const emplace =
-        (dict: Map<string, Hierarchy>) => (message: IProtocolMessage) => {
-            const accessors: string[] = message.name.split(".");
-            accessors.forEach((access, i) => {
-                const hierarchy: Hierarchy = MapUtil.take(dict)(access, () => ({
-                    key: access,
-                    message: null!,
-                    children: new Map(),
-                }));
-                dict = hierarchy.children;
-                if (i === accessors.length - 1) hierarchy.message = message;
-            });
+    const write_object = (obj: MetadataObject): string => {
+        const ptr: IPointer<number> = { value: 0 };
+        return obj.properties
+            .map((prop) => {
+                const key: string = prop.key.getSoleLiteral()!;
+                const type: string = decode(ptr)(prop.tags)(prop.value);
+                return type.indexOf("${name}") !== -1
+                    ? type.replace("${name}", key)
+                    : `${
+                          prop.value.arrays.length || key.startsWith("map<")
+                              ? ""
+                              : !prop.value.isRequired() || prop.value.nullable
+                              ? "optional "
+                              : "required"
+                      }${type} ${key} = ${++ptr.value};`;
+            })
+            .join("\n");
+    };
+
+    const decode =
+        (ptr: IPointer<number>) =>
+        (tags: IMetadataTag[]) =>
+        (meta: Metadata): string => {
+            const elements: Set<string> = new Set();
+            if (meta.natives.length) elements.add("bytes");
+            if (meta.templates.length) elements.add("string");
+            for (const atomic of meta.atomics)
+                elements.add(decode_atomic(tags)(atomic));
+            for (const constant of meta.constants)
+                elements.add(decode_atomic(tags)(constant.type));
+            for (const array of meta.arrays)
+                elements.add(`repeated ${decode(ptr)(tags)(array.value)}`);
+            for (const obj of meta.objects)
+                elements.add(
+                    is_dynamic_object(obj)
+                        ? decode_map(ptr)(tags)(obj.properties[0]!)
+                        : NameEncoder.encode(obj.name),
+                );
+            for (const map of meta.maps)
+                elements.add(decode_map(ptr)(tags)(map));
+            return elements.size === 1
+                ? [...elements][0]!
+                : [
+                      "oneof ${name} {",
+                      ...[...elements].map(
+                          (str, i) =>
+                              `${TAB}${str} v${i + 1} = ${++ptr.value};`,
+                      ),
+                      "}",
+                  ].join("\n");
+        };
+
+    const decode_atomic =
+        (tags: IMetadataTag[]) =>
+        (literal: Atomic.Literal): string => {
+            if (literal === "boolean") return "bool";
+            else if (literal === "bigint") return "int64";
+            else if (literal === "number") {
+                const type = tags.find((t) => t.kind === "type") as
+                    | IMetadataTag.INumberType
+                    | undefined;
+                return type?.value ?? "double";
+            }
+            return literal;
         };
 
-    function getTypeName(type: string | IProtocolMap): string {
-        return typeof type === "string"
-            ? NameEncoder.encode(type)
-            : `map<${type.key}, ${getTypeName(type.value)}>`;
-    }
+    const decode_map =
+        (ptr: IPointer<number>) =>
+        (tags: IMetadataTag[]) =>
+        (prop: Metadata.Entry): string =>
+            `map<${decode(ptr)([])(prop.key)}, ${decode(ptr)(tags)(
+                prop.value,
+            )}>`;
 }
 
 interface Hierarchy {
     key: string;
-    message: IProtocolMessage | null;
+    object: MetadataObject | null;
     children: Map<string, Hierarchy>;
 }
 
+interface IPointer<T> {
+    value: T;
+}
+
 const TAB = " ".repeat(4);

package/src/schemas/metadata/Metadata.ts

@@ -320,7 +320,8 @@ export class Metadata {
      */
     public isUnionBucket(): boolean {
         const size: number = this.bucket();
-        const emended: number = this.constants.length ? size - 1 : size;
+        const emended: number =
+            !!this.atomics.length && !!this.constants.length ? size - 1 : size;
         return emended > 1;
     }
 

package/src/transformers/features/protobuf/ProtobufMessageTransformer.ts

@@ -21,7 +21,7 @@ export namespace MessageTransformer {
                 throw new Error(ErrorMessages.GENERIC_ARGUMENT);
 
             // DO TRANSFORM
-            return ProtobufMessageProgrammer.generate(project)(type);
+            return ProtobufMessageProgrammer.write(project)(type);
         };
 }
 

package/src/utils/PatternUtil.ts

@@ -17,7 +17,10 @@ export namespace PatternUtil {
             .replace(/-/g, "\\x2d");
     };
 
-    export const NUMBER = "-?\\d+\\.?\\d*";
+    export const NUMBER =
+        "[+-]?" + // optional sign
+        "\\d+(?:\\.\\d+)?" + // integer or decimal
+        "(?:[eE][+-]?\\d+)?"; // optional exponent
     export const BOOLEAN = "true|false";
     export const STRING = "(.*)";
 }

package/lib/factories/ProtocolFactory.js

@@ -1,113 +0,0 @@
-"use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolFactory = void 0;
-var MetadataFactory_1 = require("./MetadataFactory");
-var emplace_protocol_object_1 = require("./internal/protocols/emplace_protocol_object");
-var iterate_protocol_main_1 = require("./internal/protocols/iterate_protocol_main");
-var ProtocolFactory;
-(function (ProtocolFactory) {
-    ProtocolFactory.metadata = function (checker) {
-        return function (collection) {
-            return function (type) {
-                return MetadataFactory_1.MetadataFactory.analyze(checker)({
-                    resolve: false,
-                    constant: true,
-                    absorb: true,
-                    validate: function (meta) {
-                        if (meta.any)
-                            throw new Error("Error on typia.message(): any type is not supported in protocol buffer.");
-                        else if (meta.functional && meta.size() !== 1)
-                            throw new Error("Error on typia.message(): functional type is not supported in protocol buffer.");
-                        else if (meta.objects.find(function (o) { return o.name === "__Main"; }))
-                            throw new Error("Error on typia.message(): reserved type \"__Main\" has been detected.");
-                        else if (meta.objects.find(function (o) { return o.name === "__Timestamp"; }))
-                            throw new Error("Error on typia.message(): reserved type \"__Timestamp\" has been detected.");
-                        else if (meta.objects.some(function (o) {
-                            return o.properties.some(function (p) { return !is_atomic_key(p.key); });
-                        }) ||
-                            meta.maps.some(function (m) { return !is_atomic_key(m.key); }))
-                            throw new Error("Error on typia.message(): only atomic key type is supported in protocol buffer.");
-                    },
-                })(collection)(type);
-            };
-        };
-    };
-    ProtocolFactory.analyze = function (collection) {
-        return function (dict) {
-            return function (meta) {
-                var e_1, _a;
-                try {
-                    for (var _b = __values(collection.objects()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var obj = _c.value;
-                        (0, emplace_protocol_object_1.emplace_protocol_object)(dict)(obj);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                (0, iterate_protocol_main_1.iterate_protocol_main)(dict)(meta);
-            };
-        };
-    };
-    var is_atomic_key = function (key) {
-        var e_2, _a, e_3, _b;
-        if (key.required &&
-            key.nullable === false &&
-            key.functional === false &&
-            key.resolved === null &&
-            key.size() ===
-                key.atomics.length +
-                    key.constants
-                        .map(function (c) { return c.values.length; })
-                        .reduce(function (a, b) { return a + b; }, 0) +
-                    key.templates.length) {
-            var set = new Set();
-            try {
-                for (var _c = __values(key.atomics), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var atomic = _d.value;
-                    set.add(atomic);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            try {
-                for (var _e = __values(key.constants), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var constant = _f.value;
-                    set.add(constant.type);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            if (key.templates.length)
-                set.add("string");
-            return set.size === 1;
-        }
-        return false;
-    };
-})(ProtocolFactory || (exports.ProtocolFactory = ProtocolFactory = {}));
-//# sourceMappingURL=ProtocolFactory.js.map

package/lib/factories/ProtocolFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProtocolFactory.js","sourceRoot":"","sources":["../../src/factories/ProtocolFactory.ts"],"names":[],"mappings":"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"}