typia 5.0.0-dev.20230829-4 → 5.0.0-dev.20230830

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,165 +1,165 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { ProtobufFactory } from "../../factories/ProtobufFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { IProject } from "../../transformers/IProject";
-
-import { MapUtil } from "../../utils/MapUtil";
-import { NameEncoder } from "../../utils/NameEncoder";
-
-import { ProtobufUtil } from "../helpers/ProtobufUtil";
-
-export namespace ProtobufMessageProgrammer {
-    export const write =
-        ({ checker }: IProject) =>
-        (type: ts.Type) => {
-            // PARSE TARGET TYPE
-            const collection: MetadataCollection = new MetadataCollection();
-            ProtobufFactory.metadata("message")(checker)(collection)(type);
-
-            // STRINGIFY
-            const hierarchies: Map<string, Hierarchy> = new Map();
-            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) => write_hierarchy(hier))
-                    .join("\n\n");
-
-            // RETURNS
-            return ts.factory.createStringLiteral(content);
-        };
-
-    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 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(
-                [...hierarchy.children.values()]
-                    .map((child) => write_hierarchy(child))
-                    .map((body) =>
-                        body
-                            .split("\n")
-                            .map((line) => `${TAB}${line}`)
-                            .join("\n"),
-                    )
-                    .join("\n\n"),
-            );
-        elements.push("}");
-        return elements.join("\n");
-    };
-
-    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.value);
-                return type.indexOf("${name}") !== -1
-                    ? type.replace("${name}", key)
-                    : `${
-                          prop.value.arrays.length || type.startsWith("map<")
-                              ? ""
-                              : !prop.value.isRequired() || prop.value.nullable
-                              ? "optional "
-                              : "required "
-                      }${type} ${key} = ${++ptr.value};`;
-            })
-            .join("\n");
-    };
-
-    /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-    const decode =
-        (ptr: IPointer<number>) =>
-        (meta: Metadata): string => {
-            const elements: Set<string> = new Set();
-            if (meta.natives.length) elements.add("bytes");
-            for (const atomic of ProtobufUtil.getAtomics(meta))
-                elements.add(atomic);
-            for (const array of meta.arrays)
-                elements.add(`repeated ${decode(ptr)(array.type.value)}`);
-            for (const obj of meta.objects)
-                elements.add(
-                    is_dynamic_object(obj)
-                        ? decode_map(ptr)(
-                              MetadataProperty.create({
-                                  ...obj.properties[0]!,
-                                  key: (() => {
-                                      const key: Metadata =
-                                          Metadata.initialize();
-                                      key.atomics.push(
-                                          MetadataAtomic.create({
-                                              type: "string",
-                                              tags: [],
-                                          }),
-                                      );
-                                      return key;
-                                  })(),
-                              }),
-                          )
-                        : NameEncoder.encode(obj.name),
-                );
-            for (const map of meta.maps) elements.add(decode_map(ptr)(map));
-            return elements.size === 1
-                ? [...elements][0]!
-                : [
-                      "oneof ${name} {",
-                      ...[...elements].map(
-                          (str) =>
-                              `${TAB}${str} v${
-                                  ptr.value + 1
-                              } = ${++ptr.value};`,
-                      ),
-                      "}",
-                  ].join("\n");
-        };
-
-    const decode_map =
-        (ptr: IPointer<number>) =>
-        (prop: Metadata.Entry): string =>
-            `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
-}
-
-interface Hierarchy {
-    key: string;
-    object: MetadataObject | null;
-    children: Map<string, Hierarchy>;
-}
-
-interface IPointer<T> {
-    value: T;
-}
-
-const TAB = " ".repeat(4);
+import ts from "typescript";
+
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { ProtobufFactory } from "../../factories/ProtobufFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { IProject } from "../../transformers/IProject";
+
+import { MapUtil } from "../../utils/MapUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
+
+import { ProtobufUtil } from "../helpers/ProtobufUtil";
+
+export namespace ProtobufMessageProgrammer {
+    export const write =
+        ({ checker }: IProject) =>
+        (type: ts.Type) => {
+            // PARSE TARGET TYPE
+            const collection: MetadataCollection = new MetadataCollection();
+            ProtobufFactory.metadata("message")(checker)(collection)(type);
+
+            // STRINGIFY
+            const hierarchies: Map<string, Hierarchy> = new Map();
+            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) => write_hierarchy(hier))
+                    .join("\n\n");
+
+            // RETURNS
+            return ts.factory.createStringLiteral(content);
+        };
+
+    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 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(
+                [...hierarchy.children.values()]
+                    .map((child) => write_hierarchy(child))
+                    .map((body) =>
+                        body
+                            .split("\n")
+                            .map((line) => `${TAB}${line}`)
+                            .join("\n"),
+                    )
+                    .join("\n\n"),
+            );
+        elements.push("}");
+        return elements.join("\n");
+    };
+
+    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.value);
+                return type.indexOf("${name}") !== -1
+                    ? type.replace("${name}", key)
+                    : `${
+                          prop.value.arrays.length || type.startsWith("map<")
+                              ? ""
+                              : !prop.value.isRequired() || prop.value.nullable
+                              ? "optional "
+                              : "required "
+                      }${type} ${key} = ${++ptr.value};`;
+            })
+            .join("\n");
+    };
+
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    const decode =
+        (ptr: IPointer<number>) =>
+        (meta: Metadata): string => {
+            const elements: Set<string> = new Set();
+            if (meta.natives.length) elements.add("bytes");
+            for (const atomic of ProtobufUtil.getAtomics(meta))
+                elements.add(atomic);
+            for (const array of meta.arrays)
+                elements.add(`repeated ${decode(ptr)(array.type.value)}`);
+            for (const obj of meta.objects)
+                elements.add(
+                    is_dynamic_object(obj)
+                        ? decode_map(ptr)(
+                              MetadataProperty.create({
+                                  ...obj.properties[0]!,
+                                  key: (() => {
+                                      const key: Metadata =
+                                          Metadata.initialize();
+                                      key.atomics.push(
+                                          MetadataAtomic.create({
+                                              type: "string",
+                                              tags: [],
+                                          }),
+                                      );
+                                      return key;
+                                  })(),
+                              }),
+                          )
+                        : NameEncoder.encode(obj.name),
+                );
+            for (const map of meta.maps) elements.add(decode_map(ptr)(map));
+            return elements.size === 1
+                ? [...elements][0]!
+                : [
+                      "oneof ${name} {",
+                      ...[...elements].map(
+                          (str) =>
+                              `${TAB}${str} v${
+                                  ptr.value + 1
+                              } = ${++ptr.value};`,
+                      ),
+                      "}",
+                  ].join("\n");
+        };
+
+    const decode_map =
+        (ptr: IPointer<number>) =>
+        (prop: Metadata.Entry): string =>
+            `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
+}
+
+interface Hierarchy {
+    key: string;
+    object: MetadataObject | null;
+    children: Map<string, Hierarchy>;
+}
+
+interface IPointer<T> {
+    value: T;
+}
+
+const TAB = " ".repeat(4);

package/src/protobuf.ts

@@ -75,17 +75,17 @@ export function message(): never {
  * For reference, as Protocol Buffer handles binary data directly, there's no way
  * when `input` binary data was not encoded from the `T` typed value. In that case,
  * unexpected behavior or internal error would be occured. Therefore, I recommend you
- * to encode binary data of Protocol Buffer from type safe encode function like below.
+ * to encode binary data of Protocol Buffer from type safe encode functions like below.
  * Use {@link encode} function only when you can ensure it.
  *
  *  - {@link assertEncode}
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * Also, `typia` is providing a type safe decoder like {@link assertDecode}, but it
- * is just for additional validation like whether a string value meets constant
- * restriction, or a numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
+ * Also, `typia` is providing type safe decoders like {@link assertDecode}, but it
+ * is just for additional type validation like `number & Minimum<7>` or
+ * `string & Format<"uuid">` cases, that are represented by
+ * [custom tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
  * you've to ensure the type safety when using decoder functions.
  *
  * @tempate Expected type of decoded value
@@ -105,17 +105,17 @@ export function decode(input: Uint8Array): never;
  * For reference, as Protocol Buffer handles binary data directly, there's no way
  * when `input` binary data was not encoded from the `T` typed value. In that case,
  * unexpected behavior or internal error would be occured. Therefore, I recommend you
- * to encode binary data of Protocol Buffer from type safe encode function like below.
+ * to encode binary data of Protocol Buffer from type safe encode functions like below.
  * Use {@link encode} function only when you can ensure it.
  *
  *  - {@link assertEncode}
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * Also, `typia` is providing a type safe decoder like {@link assertDecode}, but it
- * is just for additional validation like whether a string value meets constant
- * restriction, or a numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
+ * Also, `typia` is providing type safe decoders like {@link assertDecode}, but it
+ * is just for additional type validation like `number & Minimum<7>` or
+ * `string & Format<"uuid">` cases, that are represented by
+ * [custom tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
  * you've to ensure the type safety when using decoder functions.
  *
  * @tempate Expected type of decoded value
@@ -146,10 +146,10 @@ Object.assign(decode, Namespace.protobuf.decode("decode"));
  * {@link TypeGuardError} instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type assertion like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.assertDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -175,10 +175,10 @@ export function assertDecode(input: Uint8Array): never;
  * {@link TypeGuardError} instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type assertion like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.assertDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -215,10 +215,10 @@ Object.assign(assertDecode, Namespace.protobuf.decode("assertDecode"));
  * `null` value instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type checking like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.isDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -244,10 +244,10 @@ export function isDecode(input: Uint8Array): never;
  * `null` value instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type checking like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.isDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -285,10 +285,10 @@ Object.assign(isDecode, Namespace.protobuf.decode("isDecode"));
  * {@link IValidation.IFailure} value instead with detailed error reasons.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type validation like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.validateDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -315,10 +315,10 @@ export function validateDecode(input: Uint8Array): never;
  * {@link IValidation.IFailure} value instead with detailed error reasons.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type validation like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.validateDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *

package/src/transformers/FileTransformer.ts

@@ -45,11 +45,6 @@ export namespace FileTransformer {
                     message: exp.message,
                     code: `(${exp.code})` as any,
                 });
-                console.log(
-                    diagnostic.file.fileName,
-                    diagnostic.start,
-                    diagnostic.length,
-                );
                 project.extras.addDiagnostic(diagnostic);
                 return null;
             }