typia 3.7.0-dev.20230310 → 3.7.0-dev.20230331

package/src/metadata/Metadata.ts

@@ -205,7 +205,6 @@ export class Metadata {
     public empty(): boolean {
         return this.bucket() === 0 || this.size() === 0;
     }
-
     public size(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -224,7 +223,6 @@ export class Metadata {
             this.maps.length
         );
     }
-
     public bucket(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -241,7 +239,6 @@ export class Metadata {
             (this.maps.length ? 1 : 0)
         );
     }
-
     public isConstant(): boolean {
         return this.bucket() === (this.constants.length ? 1 : 0);
     }
@@ -511,15 +508,15 @@ function getName(metadata: Metadata): string {
         elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
 
     // ARRAY
-    if (metadata.rest !== null)
-        elements.push(`Rest<${metadata.rest.getName()}>`);
+    if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
     for (const tuple of metadata.tuples)
         elements.push(`[${tuple.map((elem) => elem.getName()).join(", ")}]`);
     for (const array of metadata.arrays)
         elements.push(`Array<${array.getName()}>`);
 
     // OBJECT
-    for (const object of metadata.objects) elements.push(object.name);
+    for (const object of metadata.objects)
+        elements.push(`Resolve<${object.name}>`);
     if (metadata.resolved !== null) elements.push(metadata.resolved.getName());
 
     // RETURNS

package/src/module.ts

@@ -1,8 +1,11 @@
+import { $dictionary } from "./functional/$dictionary";
 import { Namespace } from "./functional/Namespace";
 
 import { IMetadataApplication } from "./metadata/IMetadataApplication";
 import { IJsonApplication } from "./schemas/IJsonApplication";
 
+import { Customizable } from "./typings/Customizable";
+
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Primitive } from "./Primitive";
@@ -20,7 +23,6 @@ export * from "./TypeGuardError";
     SINGLE FUNCTIONS
         - BASIC VALIDATORS
         - STRICT VALIDATORS
-        - PROTOCOL BUFFER FUNCTIONS
         - JSON FUNCTIONS
         - MISCELLANEOUS
 ==============================================================
@@ -411,15 +413,42 @@ export function validateEquals(): never {
 }
 Object.assign(validateEquals, Namespace.validate());
 
-/* -----------------------------------------------------------
-    PROTOCOL BUFFER FUNCTIONS
------------------------------------------------------------ */
-export function message(): never;
-export function message<T>(): string;
-
-export function message(): string {
-    halt("message");
-}
+/**
+ * Add validation tag.
+ *
+ * If you want to add a custom validation logic, you can use this function.
+ *
+ * ```ts
+ * typia.addValidationTag("powerOf")("number")(
+ *     (text: string) => {
+ *         const denominator: number = Math.log(Number(text));
+ *         return (value: number) => {
+ *             value = Math.log(value) / denominator;
+ *             return value === Math.floor(value);
+ *         };
+ *     }
+ * );
+ * typia.addValidationTag("dollar")("string")(
+ *     () => (value: string) => value.startsWith("$"),
+ * );
+ * ```
+ *
+ * @param name Name of tag (`@name`)
+ * @returns Currying function
+ */
+export const addValidationTag =
+    (name: string) =>
+    /**
+     * @param type Type of target value
+     */
+    <Type extends keyof Customizable>(type: Type) =>
+    /**
+     * @param closure Closure function for custom validation
+     */
+    (closure: (text: string) => (value: Customizable[Type]) => boolean) => {
+        const key = `${name}:${type}` as const;
+        if (!$dictionary.has(key)) $dictionary.set(key, closure);
+    };
 
 /* -----------------------------------------------------------
     JSON FUNCTIONS

package/src/programmers/CheckerProgrammer.ts

@@ -217,6 +217,7 @@ export namespace CheckerProgrammer {
         meta: Metadata,
         explore: IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
     ) => ts.Expression;
 
     /**
@@ -232,6 +233,7 @@ export namespace CheckerProgrammer {
         meta: Metadata,
         explore: IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
     ) => ts.Expression;
 
     /**
@@ -246,7 +248,8 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression {
             if (meta.any) return config.success;
 
@@ -315,20 +318,28 @@ export namespace CheckerProgrammer {
                 if (AtomicPredicator.atomic(meta)(type) === false) continue;
                 else if (type === "number")
                     binaries.push({
-                        expression: check_number(project, config.numeric)(
-                            input,
-                            tags,
-                        ),
+                        expression: check_number(
+                            project,
+                            config.numeric,
+                        )(importer)(input, metaTags, jsDocTags),
                         combined: false,
                     });
                 else if (type === "bigint")
                     binaries.push({
-                        expression: check_bigint(input, tags),
+                        expression: check_bigint(importer)(
+                            input,
+                            metaTags,
+                            jsDocTags,
+                        ),
                         combined: false,
                     });
                 else if (type === "string")
                     binaries.push({
-                        expression: check_string(importer)(input, tags),
+                        expression: check_string(importer)(
+                            input,
+                            metaTags,
+                            jsDocTags,
+                        ),
                         combined: false,
                     });
                 else
@@ -345,7 +356,7 @@ export namespace CheckerProgrammer {
                         expression: check_template(importer)(
                             input,
                             meta.templates,
-                            tags,
+                            metaTags,
                         ),
                         combined: false,
                     });
@@ -394,6 +405,7 @@ export namespace CheckerProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                     );
             }
@@ -418,6 +430,7 @@ export namespace CheckerProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                     );
             }
@@ -425,7 +438,11 @@ export namespace CheckerProgrammer {
             // ARRAYS AND TUPLES
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
-                    check_array(input, meta.tuples.length === 0 ? tags : []),
+                    check_array(importer)(
+                        input,
+                        meta.tuples.length === 0 ? metaTags : [],
+                        jsDocTags,
+                    ),
                     [...meta.tuples, ...meta.arrays]
                         .map((elem) =>
                             Array.isArray(elem)
@@ -445,7 +462,8 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            tags,
+                            metaTags,
+                            jsDocTags,
                         ),
                     );
                 else if (meta.arrays.some((elem) => elem.any)) install(null);
@@ -459,7 +477,8 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            tags,
+                            metaTags,
+                            jsDocTags,
                         ),
                     );
                 else
@@ -468,7 +487,8 @@ export namespace CheckerProgrammer {
                             input,
                             [...meta.tuples, ...meta.arrays],
                             explore,
-                            tags,
+                            metaTags,
+                            jsDocTags,
                         ),
                     );
             }
@@ -580,6 +600,7 @@ export namespace CheckerProgrammer {
             tuple: Array<Metadata>,
             explore: IExplore,
             tagList: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression {
             const binaries: ts.Expression[] = tuple
                 .filter((meta) => meta.rest === null)
@@ -595,6 +616,7 @@ export namespace CheckerProgrammer {
                                 : `[${index}]`,
                         },
                         tagList,
+                        jsDocTags,
                     ),
                 );
             const rest: ts.Expression | null =
@@ -621,6 +643,7 @@ export namespace CheckerProgrammer {
                               start: tuple.length - 1,
                           },
                           tagList,
+                          jsDocTags,
                       )
                     : null;
 
@@ -728,12 +751,14 @@ export namespace CheckerProgrammer {
                         entry[0],
                         { ...explore, postfix: `${explore.postfix}[0]` },
                         [],
+                        [],
                     ),
                     func(
                         ts.factory.createElementAccessExpression(input, 1),
                         entry[1],
                         { ...explore, postfix: `${explore.postfix}[1]` },
                         [],
+                        [],
                     ),
                 );
             },
@@ -759,6 +784,7 @@ export namespace CheckerProgrammer {
                     }),
                     explore,
                     [],
+                    [],
                 ),
             empty: config.success,
             success: config.success,
@@ -806,13 +832,14 @@ export namespace CheckerProgrammer {
         importer: FunctionImporter,
     ) =>
         UnionExplorer.array_or_tuple({
-            checker: (front, target, explore, tags, array) => {
+            checker: (front, target, explore, tags, jsDocTags, array) => {
                 if (Array.isArray(target))
                     return check_union_tuple(project, config, importer)(
                         front,
                         target,
                         explore,
                         tags,
+                        jsDocTags,
                         array,
                     );
                 const condition = decode(project, config, importer)(
@@ -820,25 +847,28 @@ export namespace CheckerProgrammer {
                     target,
                     explore,
                     tags,
+                    jsDocTags,
                 );
                 const length = check_array_length(array, tags);
                 return length !== null
                     ? ts.factory.createBitwiseAnd(condition, length)
                     : condition;
             },
-            decoder: (input, target, explore, tags) =>
+            decoder: (input, target, explore, tags, jsDocTags) =>
                 Array.isArray(target)
                     ? decode_tuple(project, config, importer, true)(
                           input,
                           target,
                           explore,
                           tags,
+                          jsDocTags,
                       )
                     : decode_array(project, config, importer, true)(
                           input,
                           target,
                           explore,
                           tags,
+                          jsDocTags,
                       ),
             empty: config.success,
             success: config.success,

package/src/programmers/CloneProgrammer.ts

@@ -109,6 +109,7 @@ export namespace CloneProgrammer {
                             })(),
                             explore,
                             [],
+                            [],
                         ),
                     value: () =>
                         decode_tuple(project, importer)(input, tuple, explore),
@@ -128,6 +129,7 @@ export namespace CloneProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                 });
 

package/src/programmers/FeatureProgrammer.ts

@@ -6,6 +6,7 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
 import { MetadataObject } from "../metadata/MetadataObject";
@@ -202,7 +203,8 @@ export namespace FeatureProgrammer {
             input: ts.Expression,
             target: T,
             explore: IExplore,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): Output;
     }
 
@@ -241,6 +243,7 @@ export namespace FeatureProgrammer {
                     postfix: '""',
                 },
                 [],
+                [],
             );
 
             // RETURNS THE OPTIMAL ARROW FUNCTION
@@ -350,6 +353,7 @@ export namespace FeatureProgrammer {
                         postfix: "",
                     },
                     [],
+                    [],
                 ),
             );
     }
@@ -363,7 +367,8 @@ export namespace FeatureProgrammer {
         combiner: (
             input: ts.Expression,
             arrow: ts.ArrowFunction,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ) => ts.Expression,
     ) {
         const rand: string = importer.increment().toString();
@@ -381,7 +386,8 @@ export namespace FeatureProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            tags: IMetadataTag[],
+            metaTags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
         ) => {
             const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
                 undefined,
@@ -406,10 +412,11 @@ export namespace FeatureProgrammer {
                             explore.postfix,
                         )(rand),
                     },
-                    tags,
+                    metaTags,
+                    jsDocTags,
                 ),
             );
-            return combiner(input, arrow, tags);
+            return combiner(input, arrow, metaTags, jsDocTags);
         };
     }
 

package/src/programmers/IsProgrammer.ts

@@ -105,7 +105,7 @@ export namespace IsProgrammer {
         })(importer);
         config.trace = equals;
 
-        config.decoder = (input, target, explore, tags) => {
+        config.decoder = (input, target, explore, tags, jsDocTags) => {
             if (
                 target.size() === 1 &&
                 target.objects.length === 1 &&
@@ -137,6 +137,7 @@ export namespace IsProgrammer {
                 target,
                 explore,
                 tags,
+                jsDocTags,
             );
         };
 

package/src/programmers/PruneProgrammer.ts

@@ -88,6 +88,7 @@ export namespace PruneProgrammer {
                             })(),
                             explore,
                             [],
+                            [],
                         ),
                     value: () =>
                         decode_tuple(project, importer)(input, tuple, explore),
@@ -107,6 +108,7 @@ export namespace PruneProgrammer {
                                 from: "array",
                             },
                             [],
+                            [],
                         ),
                 });
 

package/src/programmers/RandomProgrammer.ts

@@ -344,10 +344,7 @@ export namespace RandomProgrammer {
         (importer: FunctionImporter) =>
         (tags: IMetadataTag[]): ts.Expression => {
             for (const t of tags)
-                if (
-                    t.kind === "format" &&
-                    ["uuid", "email", "url", "ipv4", "ipv6"].includes(t.value)
-                )
+                if (t.kind === "format")
                     return ts.factory.createCallExpression(
                         COALESCE(importer)(t.value),
                         undefined,

package/src/programmers/StringifyProgrammer.ts

@@ -172,6 +172,7 @@ export namespace StringifyProgrammer {
                                     partial,
                                     explore,
                                     [],
+                                    [],
                                 ),
                             value: () =>
                                 decode_atomic(project, importer)(
@@ -200,6 +201,7 @@ export namespace StringifyProgrammer {
                                 })(),
                                 explore,
                                 [],
+                                [],
                             ),
                         value: () =>
                             decode_atomic(project, importer)(
@@ -222,6 +224,7 @@ export namespace StringifyProgrammer {
                                 })(),
                                 explore,
                                 [],
+                                [],
                             ),
                         value: () =>
                             decode_constant_string(project, importer)(
@@ -246,6 +249,7 @@ export namespace StringifyProgrammer {
                                 })(),
                                 explore,
                                 [],
+                                [],
                             ),
                         value: () =>
                             decode_atomic(project, importer)(
@@ -275,6 +279,7 @@ export namespace StringifyProgrammer {
                             })(),
                             explore,
                             [],
+                            [],
                         ),
                     value: () =>
                         decode_tuple(project, importer)(
@@ -311,6 +316,7 @@ export namespace StringifyProgrammer {
                                   from: "array",
                               },
                               [],
+                              [],
                           );
 
                 unions.push({

package/src/programmers/helpers/UnionExplorer.ts

@@ -18,6 +18,7 @@ export namespace UnionExplorer {
             target: T,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression;
     }
     export type ObjectCombiner = Decoder<MetadataObject[]>;
@@ -32,6 +33,7 @@ export namespace UnionExplorer {
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             // BREAKER
             if (targets.length === 1)
@@ -40,6 +42,7 @@ export namespace UnionExplorer {
                     targets[0]!,
                     explore,
                     tags,
+                    jsDocTags,
                 );
 
             const expected: string = `(${targets
@@ -57,6 +60,7 @@ export namespace UnionExplorer {
                         tracable: false,
                     },
                     tags,
+                    jsDocTags,
                 );
                 return config.objector.full
                     ? config.objector.full(condition)(input, expected, explore)
@@ -85,6 +89,7 @@ export namespace UnionExplorer {
                                   postfix: IdentifierFactory.postfix(key),
                               },
                               tags,
+                              jsDocTags,
                           )
                         : (config.objector.required || ((exp) => exp))(
                               ExpressionFactory.isRequired(accessor),
@@ -97,6 +102,7 @@ export namespace UnionExplorer {
                                 spec.object,
                                 explore,
                                 tags,
+                                jsDocTags,
                             ),
                         ),
                     );
@@ -120,6 +126,7 @@ export namespace UnionExplorer {
                                           remained,
                                           explore,
                                           tags,
+                                          jsDocTags,
                                       ),
                                   )
                                 : config.objector.failure(

package/src/programmers/internal/application_object.ts

@@ -18,10 +18,10 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (id: string, obj: MetadataObject, nullable: boolean): void => {
+    (key: string, obj: MetadataObject, nullable: boolean): void => {
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[id] !== undefined) return;
-        components.schemas[id] = {} as any;
+        if (components.schemas[key] !== undefined) return;
+        components.schemas[key] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -97,7 +97,7 @@ export const application_object =
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
-                    ? options.prefix + "/" + id
+                    ? options.prefix + "/" + key
                     : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
@@ -118,7 +118,7 @@ export const application_object =
                           join(options)(components)(extraMeta),
                   }),
         };
-        components.schemas[id] = schema;
+        components.schemas[key] = schema;
     };
 
 const join =

package/src/programmers/internal/application_schema.ts

@@ -2,8 +2,6 @@ import { Metadata } from "../../metadata/Metadata";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
-import { NameEncoder } from "../../utils/NameEncoder";
-
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
 import { application_array } from "./application_array";
@@ -144,14 +142,12 @@ export const application_schema =
 
         // OBJECT
         for (const obj of meta.objects) {
-            const id: string =
-                NameEncoder.encode(obj.name) +
-                (meta.nullable ? ".Nullable" : "");
-            application_object(options)(components)(id, obj, meta.nullable);
+            const key: string = obj.name + (meta.nullable ? ".Nullable" : "");
+            application_object(options)(components)(key, obj, meta.nullable);
             union.push(
                 (options.purpose === "ajv" && obj.recursive
                     ? recursive
-                    : reference)(`${options.prefix}/${id}`, attribute),
+                    : reference)(`${options.prefix}/${key}`, attribute),
             );
         }
 

package/src/programmers/internal/application_string.ts

@@ -1,3 +1,4 @@
+import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
@@ -24,12 +25,12 @@ export const application_string = (
         output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
 
     // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
-    for (const tag of attribute["x-typia-metaTags"] || []) {
+    for (const tag of attribute["x-typia-metaTags"] ?? []) {
         // RANGE
         if (tag.kind === "minLength") output.minLength = tag.value;
         else if (tag.kind === "maxLength") output.maxLength = tag.value;
         // FORMAT AND PATTERN
-        else if (tag.kind === "format") output.format = tag.value;
+        else if (tag.kind === "format") output.format = emendFormat(tag.value);
         else if (tag.kind === "pattern") output.pattern = tag.value;
     }
 
@@ -39,3 +40,6 @@ export const application_string = (
     // RETURNS
     return output;
 };
+
+const emendFormat = (tag: IMetadataTag.IFormat["value"]) =>
+    tag === "datetime" ? "date-time" : tag;