typia 5.2.6 → 5.3.0-dev.20231112

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -16,27 +16,27 @@ 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);
-        };
+    export const write = (project: IProject) => (type: ts.Type) => {
+        // PARSE TARGET TYPE
+        const collection: MetadataCollection = new MetadataCollection();
+        ProtobufFactory.metadata("message")(project.checker, project.context)(
+            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(".");

package/src/reflect.ts

@@ -0,0 +1,24 @@
+import { Namespace } from "./functional/Namespace";
+
+import { MetadataApplication } from "./schemas/metadata/MetadataApplication";
+
+export function metadata(): never;
+
+export function metadata<Types extends unknown[]>(): MetadataApplication;
+
+/**
+ * @internal
+ */
+export function metadata(): never {
+    halt("metadata");
+}
+Object.assign(metadata, Namespace.reflect.metadata());
+
+/**
+ * @internal
+ */
+function halt(name: string): never {
+    throw new Error(
+        `Error on typia.reflect.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
+    );
+}

package/src/schemas/json/IJsonSchema.ts

@@ -72,6 +72,7 @@ export namespace IJsonSchema {
         minItems?: undefined | (number & Type<"uint32">);
         maxItems?: undefined | (number & Type<"uint32">);
         "x-typia-tuple"?: undefined | ITuple;
+        "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];

package/src/schemas/metadata/IMetadataApplication.ts

@@ -1,7 +1,7 @@
 import { IMetadata } from "./IMetadata";
-import { IMetadataCollection } from "./IMetadataCollection";
+import { IMetadataComponents } from "./IMetadataComponents";
 
 export interface IMetadataApplication {
     metadatas: IMetadata[];
-    collection: IMetadataCollection;
+    components: IMetadataComponents;
 }

package/src/schemas/metadata/{IMetadataCollection.ts → IMetadataComponents.ts}

@@ -3,7 +3,7 @@ import { IMetadataArrayType } from "./IMetadataArrayType";
 import { IMetadataObject } from "./IMetadataObject";
 import { IMetadataTupleType } from "./IMetadataTupleType";
 
-export interface IMetadataCollection {
+export interface IMetadataComponents {
     objects: IMetadataObject[];
     aliases: IMetadataAlias[];
     arrays: IMetadataArrayType[];

package/src/schemas/metadata/IMetadataConstant.ts

@@ -6,7 +6,7 @@ export type IMetadataConstant =
     | IMetadataConstant.IBase<"boolean", boolean>
     | IMetadataConstant.IBase<"number", number>
     | IMetadataConstant.IBase<"string", string>
-    | IMetadataConstant.IBase<"bigint", bigint>;
+    | IMetadataConstant.IBase<"bigint", string>;
 export namespace IMetadataConstant {
     export interface IBase<
         Type extends Atomic.Literal,

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -1,8 +1,15 @@
+import type ts from "typescript";
+
 export interface IMetadataTypeTag {
     target: "boolean" | "bigint" | "number" | "string" | "array";
     name: string;
     kind: string;
-    value: any;
-    validate: string | undefined;
     exclusive: boolean | string[];
+    value?: any;
+    validate?: string | undefined;
+
+    /**
+     * @internal
+     */
+    predicate?: (input: ts.Expression) => ts.Expression;
 }

package/src/schemas/metadata/Metadata.ts

@@ -1,22 +1,17 @@
 import { ClassProperties } from "../../typings/ClassProperties";
-import { Writable } from "../../typings/Writable";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
 
 import { IMetadata } from "./IMetadata";
-import { IMetadataCollection } from "./IMetadataCollection";
 import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArray } from "./MetadataArray";
-import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
 import { MetadataTuple } from "./MetadataTuple";
-import { MetadataTupleType } from "./MetadataTupleType";
 
 export class Metadata {
     public any: boolean;
@@ -86,7 +81,7 @@ export class Metadata {
      * @internal
      */
     public static initialize(parentResolved: boolean = false): Metadata {
-        const meta: Metadata = this.create({
+        const meta: Metadata = Metadata.create({
             any: false,
             nullable: false,
             required: true,
@@ -119,16 +114,8 @@ export class Metadata {
             nullable: this.nullable,
             functional: this.functional,
 
-            atomics: this.atomics.map((a) =>
-                MetadataAtomic.create({
-                    type: a.type,
-                    tags: a.tags.map((r) => r.slice()),
-                }),
-            ),
-            constants: this.constants.map((c) => ({
-                type: c.type,
-                values: c.values.slice() as any,
-            })),
+            atomics: this.atomics.map((a) => a.toJSON()),
+            constants: this.constants.map((c) => c.toJSON()),
             templates: this.templates.map((tpl) =>
                 tpl.map((meta) => meta.toJSON()),
             ),
@@ -155,85 +142,24 @@ export class Metadata {
         };
     }
 
-    public static from(
-        meta: IMetadata,
-        collection: IMetadataCollection,
-    ): Metadata {
-        const dict: IMetadataDictionary = {
-            objects: new Map(
-                collection.objects.map((obj) => [
-                    obj.name,
-                    MetadataObject._From_without_properties(obj),
-                ]),
-            ),
-            aliases: new Map(
-                collection.aliases.map((alias) => [
-                    alias.name,
-                    MetadataAlias._From_without_value(alias),
-                ]),
-            ),
-            arrays: new Map(
-                collection.arrays.map((arr) => [
-                    arr.name,
-                    MetadataArrayType._From_without_value(arr),
-                ]),
-            ),
-            tuples: new Map(
-                collection.tuples.map((tpl) => [
-                    tpl.name,
-                    MetadataTupleType._From_without_elements(tpl),
-                ]),
-            ),
-        };
-
-        for (const obj of collection.objects) {
-            const initialized = dict.objects.get(obj.name)!;
-            initialized.properties.push(
-                ...obj.properties.map((prop) =>
-                    MetadataProperty._From(prop, dict),
-                ),
-            );
-        }
-        for (const alias of collection.aliases)
-            Writable(dict.aliases.get(alias.name)!).value = this._From(
-                alias.value,
-                dict,
-            );
-        for (const array of collection.arrays)
-            Writable(dict.arrays.get(array.name)!).value = this._From(
-                array.value,
-                dict,
-            );
-        for (const tuple of collection.tuples)
-            Writable(dict.tuples.get(tuple.name)!).elements =
-                tuple.elements.map((elem) => this._From(elem, dict));
-
-        return this._From(meta, dict);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From(meta: IMetadata, dict: IMetadataDictionary): Metadata {
-        return this.create({
+    public static from(meta: IMetadata, dict: IMetadataDictionary): Metadata {
+        return Metadata.create({
             any: meta.any,
             required: meta.required,
             optional: meta.optional,
             nullable: meta.nullable,
             functional: meta.functional,
 
-            constants: meta.constants.slice(),
-            atomics: meta.atomics.map((a) =>
-                MetadataAtomic.create({ type: a.type, tags: a.tags }),
-            ),
+            constants: meta.constants.map(MetadataConstant.from),
+            atomics: meta.atomics.map(MetadataAtomic.from),
             templates: meta.templates.map((tpl) =>
-                tpl.map((meta) => this._From(meta, dict)),
+                tpl.map((meta) => this.from(meta, dict)),
             ),
             escaped: meta.escaped
-                ? MetadataEscaped._From(meta.escaped, dict)
+                ? MetadataEscaped.from(meta.escaped, dict)
                 : null,
 
-            rest: meta.rest ? this._From(meta.rest, dict) : null,
+            rest: meta.rest ? this.from(meta.rest, dict) : null,
             arrays: meta.arrays.map((ref) => {
                 const type = dict.arrays.get(ref.name);
                 if (type === undefined)
@@ -274,10 +200,10 @@ export class Metadata {
             }),
 
             natives: meta.natives.slice(),
-            sets: meta.sets.map((meta) => this._From(meta, dict)),
+            sets: meta.sets.map((meta) => this.from(meta, dict)),
             maps: meta.maps.map((entry) => ({
-                key: this._From(entry.key, dict),
-                value: this._From(entry.value, dict),
+                key: this.from(entry.key, dict),
+                value: this.from(entry.value, dict),
             })),
         });
     }
@@ -570,10 +496,11 @@ export namespace Metadata {
             const target: MetadataConstant = ArrayUtil.take(
                 output.constants,
                 (elem) => elem.type === constant.type,
-                () => ({
-                    type: constant.type,
-                    values: [],
-                }),
+                () =>
+                    MetadataConstant.create({
+                        type: constant.type,
+                        values: [],
+                    }),
             );
             for (const value of constant.values)
                 ArrayUtil.add(target.values, value);

package/src/schemas/metadata/MetadataAlias.ts

@@ -38,7 +38,7 @@ export class MetadataAlias {
      * @internal
      */
     public static _From_without_value(props: Omit<IMetadataAlias, "value">) {
-        return this.create({
+        return MetadataAlias.create({
             name: props.name,
             value: null!,
             description: props.description,

package/src/schemas/metadata/MetadataApplication.ts

@@ -0,0 +1,44 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataApplication } from "./IMetadataApplication";
+import { Metadata } from "./Metadata";
+import { MetadataComponents } from "./MetadataComponents";
+
+export class MetadataApplication {
+    public readonly metadatas: Metadata[];
+    public readonly components: MetadataComponents;
+
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataApplication>) {
+        this.metadatas = props.metadatas;
+        this.components = props.components;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataApplication>,
+    ): MetadataApplication {
+        return new MetadataApplication(props);
+    }
+
+    public static from(app: IMetadataApplication): MetadataApplication {
+        const components: MetadataComponents = MetadataComponents.from(
+            app.components,
+        );
+        const metadatas: Metadata[] = app.metadatas.map((metadata) =>
+            Metadata.from(metadata, components.dictionary),
+        );
+        return MetadataApplication.create({ metadatas, components });
+    }
+
+    public toJSON(): IMetadataApplication {
+        return {
+            metadatas: this.metadatas.map((metadata) => metadata.toJSON()),
+            components: this.components.toJSON(),
+        };
+    }
+}

package/src/schemas/metadata/MetadataArrayType.ts

@@ -27,7 +27,7 @@ export class MetadataArrayType {
     public static _From_without_value(
         props: Omit<IMetadataArrayType, "value">,
     ): MetadataArrayType {
-        return this.create({
+        return MetadataArrayType.create({
             name: props.name,
             value: null!,
             index: props.index,

package/src/schemas/metadata/MetadataAtomic.ts

@@ -1,5 +1,6 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
+import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export class MetadataAtomic {
@@ -22,6 +23,27 @@ export class MetadataAtomic {
         return new MetadataAtomic(props);
     }
 
+    public static from(json: IMetadataAtomic): MetadataAtomic {
+        return MetadataAtomic.create({
+            type: json.type,
+            tags: json.tags.map((row) =>
+                row.map((tag) => ({
+                    target: tag.target,
+                    name: tag.name,
+                    kind: tag.kind,
+                    value:
+                        typeof tag.value === "object" &&
+                        tag.value?.type === "bigint" &&
+                        typeof tag.value.value === "string"
+                            ? BigInt(tag.value.value)
+                            : tag.value,
+                    validate: tag.validate,
+                    exclusive: tag.exclusive,
+                })),
+            ),
+        });
+    }
+
     public getName(): string {
         return (this.name_ ??= (() => {
             if (this.tags.length === 0) return this.type;
@@ -39,4 +61,26 @@ export class MetadataAtomic {
             return `(${this.type} & (${rows.join(" | ")}))`;
         })());
     }
+
+    public toJSON(): IMetadataAtomic {
+        return {
+            type: this.type,
+            tags: this.tags.map((row) =>
+                row.map((tag) => ({
+                    target: tag.target,
+                    name: tag.name,
+                    kind: tag.kind,
+                    value:
+                        typeof tag.value === "bigint"
+                            ? {
+                                  type: "bigint",
+                                  value: tag.value.toString(),
+                              }
+                            : tag.value,
+                    validate: tag.validate,
+                    exclusive: tag.exclusive,
+                })),
+            ),
+        };
+    }
 }

package/src/schemas/metadata/MetadataComponents.ts

@@ -0,0 +1,98 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+import { Writable } from "../../typings/Writable";
+
+import { IMetadataComponents } from "./IMetadataComponents";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { Metadata } from "./Metadata";
+import { MetadataAlias } from "./MetadataAlias";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataObject } from "./MetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export class MetadataComponents {
+    public readonly aliases: MetadataAlias[];
+    public readonly objects: MetadataObject[];
+    public readonly arrays: MetadataArrayType[];
+    public readonly tuples: MetadataTupleType[];
+    public readonly dictionary: IMetadataDictionary;
+
+    private constructor(props: ClassProperties<MetadataComponents>) {
+        this.aliases = props.aliases;
+        this.objects = props.objects;
+        this.arrays = props.arrays;
+        this.tuples = props.tuples;
+        this.dictionary = props.dictionary;
+    }
+
+    public static from(json: IMetadataComponents): MetadataComponents {
+        // INITIALIZE COMPONENTS
+        const dictionary: IMetadataDictionary = {
+            objects: new Map(
+                json.objects.map((obj) => [
+                    obj.name,
+                    MetadataObject._From_without_properties(obj),
+                ]),
+            ),
+            aliases: new Map(
+                json.aliases.map((alias) => [
+                    alias.name,
+                    MetadataAlias._From_without_value(alias),
+                ]),
+            ),
+            arrays: new Map(
+                json.arrays.map((arr) => [
+                    arr.name,
+                    MetadataArrayType._From_without_value(arr),
+                ]),
+            ),
+            tuples: new Map(
+                json.tuples.map((tpl) => [
+                    tpl.name,
+                    MetadataTupleType._From_without_elements(tpl),
+                ]),
+            ),
+        };
+
+        // CONSTRUCT METADATA OF THEM
+        for (const obj of json.objects)
+            dictionary.objects
+                .get(obj.name)!
+                .properties.push(
+                    ...obj.properties.map((prop) =>
+                        MetadataProperty.from(prop, dictionary),
+                    ),
+                );
+        for (const alias of json.aliases)
+            Writable(dictionary.aliases.get(alias.name)!).value = Metadata.from(
+                alias.value,
+                dictionary,
+            );
+        for (const array of json.arrays)
+            Writable(dictionary.arrays.get(array.name)!).value = Metadata.from(
+                array.value,
+                dictionary,
+            );
+        for (const tuple of json.tuples)
+            Writable(dictionary.tuples.get(tuple.name)!).elements =
+                tuple.elements.map((elem) => Metadata.from(elem, dictionary));
+
+        // FINALIZE
+        return new MetadataComponents({
+            aliases: [...dictionary.aliases.values()],
+            objects: [...dictionary.objects.values()],
+            arrays: [...dictionary.arrays.values()],
+            tuples: [...dictionary.tuples.values()],
+            dictionary,
+        });
+    }
+
+    public toJSON(): IMetadataComponents {
+        return {
+            aliases: this.aliases.map((alias) => alias.toJSON()),
+            objects: this.objects.map((object) => object.toJSON()),
+            arrays: this.arrays.map((array) => array.toJSON()),
+            tuples: this.tuples.map((tuple) => tuple.toJSON()),
+        };
+    }
+}

package/src/schemas/metadata/MetadataConstant.ts

@@ -1,3 +1,46 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
 import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export class MetadataConstant {
+    public readonly type: "boolean" | "bigint" | "number" | "string";
+    public readonly values: boolean[] | bigint[] | number[] | string[];
+
+    /**
+     * @internal
+     */
+    public tags?: IMetadataTypeTag[][] | undefined;
+
+    private constructor(props: ClassProperties<MetadataConstant>) {
+        this.type = props.type;
+        this.values = props.values;
+        this.tags = props.tags;
+    }
+
+    public static create(
+        props: ClassProperties<MetadataConstant>,
+    ): MetadataConstant {
+        return new MetadataConstant(props);
+    }
+
+    public static from(json: IMetadataConstant): MetadataConstant {
+        return MetadataConstant.create({
+            type: json.type,
+            values:
+                json.type === "bigint"
+                    ? json.values.map((v) => BigInt(v))
+                    : (json.values as any[]),
+        });
+    }
 
-export type MetadataConstant = IMetadataConstant;
+    public toJSON(): IMetadataConstant {
+        return {
+            type: this.type,
+            values:
+                this.type === "bigint"
+                    ? this.values.map((v) => v.toString())
+                    : (this.values as any[]),
+        };
+    }
+}

package/src/schemas/metadata/MetadataEscaped.ts

@@ -19,13 +19,13 @@ export class MetadataEscaped {
     /**
      * @internal
      */
-    public static _From(
+    public static from(
         props: IMetadataEscaped,
         dict: IMetadataDictionary,
     ): MetadataEscaped {
-        return this.create({
-            original: Metadata._From(props.original, dict),
-            returns: Metadata._From(props.returns, dict),
+        return MetadataEscaped.create({
+            original: Metadata.from(props.original, dict),
+            returns: Metadata.from(props.returns, dict),
         });
     }
 

package/src/schemas/metadata/MetadataObject.ts

@@ -37,7 +37,7 @@ export class MetadataObject {
         this.index = props.index;
         this.validated = props.validated;
         this.recursive = props.recursive;
-        this.nullables = [];
+        this.nullables = props.nullables.slice();
 
         this.tagged_ = false;
     }
@@ -57,7 +57,7 @@ export class MetadataObject {
     public static _From_without_properties(
         obj: IMetadataObject,
     ): MetadataObject {
-        return this.create({
+        return MetadataObject.create({
             name: obj.name,
             properties: [],
             description: obj.description,

package/src/schemas/metadata/MetadataProperty.ts

@@ -36,13 +36,10 @@ export class MetadataProperty {
     /**
      * @internal
      */
-    public static _From(
-        property: IMetadataProperty,
-        dict: IMetadataDictionary,
-    ) {
-        return this.create({
-            key: Metadata._From(property.key, dict),
-            value: Metadata._From(property.value, dict),
+    public static from(property: IMetadataProperty, dict: IMetadataDictionary) {
+        return MetadataProperty.create({
+            key: Metadata.from(property.key, dict),
+            value: Metadata.from(property.value, dict),
             description: property.description,
             jsDocTags: property.jsDocTags.slice(),
         });

package/src/schemas/metadata/MetadataTupleType.ts

@@ -33,7 +33,7 @@ export class MetadataTupleType {
     public static _From_without_elements(
         props: Omit<IMetadataTupleType, "elements">,
     ): MetadataTupleType {
-        return this.create({
+        return MetadataTupleType.create({
             name: props.name,
             index: props.index,
             elements: null!,