typia 3.7.0-dev.20230310 → 3.7.0-dev.20230401

package/src/programmers/internal/check_number.ts

@@ -1,64 +1,29 @@
 import ts from "typescript";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { IProject } from "../../transformers/IProject";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 import { OptionPredicator } from "../helpers/OptionPredicator";
+import { check_custom } from "./check_custom";
 
 /**
  * @internal
  */
 export const check_number =
-    ({ options }: IProject, numeric: boolean) =>
-    (input: ts.Expression, tagList: IMetadataTag[]) => {
-        // TYPEOF STATEMENT
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("number"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-
-        // CHECK FINITE AND NAN
-        const finite: boolean =
-            (!!tagList.find(
-                (tag) =>
-                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
-            ) &&
-                !!tagList.find(
-                    (tag) =>
-                        tag.kind === "maximum" ||
-                        tag.kind === "exclusiveMaximum",
-                )) ||
-            !!tagList.find(
-                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
-            );
-
-        if (numeric === true && finite === false)
-            if (OptionPredicator.finite(options))
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Number.isFinite"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            else if (OptionPredicator.numeric(options))
-                conditions.push(
-                    ts.factory.createLogicalNot(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-
-        // TAG (RANGE)
-        for (const tag of tagList)
+    (project: IProject, numeric: boolean) =>
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTag: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => {
+        const entries: [IMetadataTag, ts.Expression][] = [];
+        for (const tag of metaTags)
             if (tag.kind === "type") {
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createCallExpression(
                             ts.factory.createIdentifier("parseInt"),
@@ -67,16 +32,18 @@ export const check_number =
                         ),
                         input,
                     ),
-                );
+                ]);
                 if (tag.value === "uint")
-                    conditions.push(
+                    entries.push([
+                        tag,
                         ts.factory.createLessThanEquals(
                             ts.factory.createNumericLiteral(0),
                             input,
                         ),
-                    );
+                    ]);
             } else if (tag.kind === "multipleOf")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(0),
                         ts.factory.createModulo(
@@ -84,61 +51,123 @@ export const check_number =
                             ts.factory.createNumericLiteral(tag.value),
                         ),
                     ),
-                );
+                ]);
             else if (tag.kind === "step") {
-                const modulo = () =>
-                    ts.factory.createModulo(
-                        input,
-                        ts.factory.createNumericLiteral(tag.value),
-                    );
-                const minimum = (() => {
-                    for (const tag of tagList)
-                        if (tag.kind === "minimum") return tag.value;
-                        else if (tag.kind === "exclusiveMinimum")
-                            return tag.value;
-                    return undefined;
-                })();
-                conditions.push(
+                const modulo = ts.factory.createModulo(
+                    input,
+                    ts.factory.createNumericLiteral(tag.value),
+                );
+                const minimum =
+                    (metaTags.find(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    )?.value as number | undefined) ?? undefined;
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(0),
                         minimum !== undefined
                             ? ts.factory.createSubtract(
-                                  modulo(),
+                                  modulo,
                                   ts.factory.createNumericLiteral(minimum),
                               )
-                            : modulo(),
+                            : modulo,
                     ),
-                );
+                ]);
             } else if (tag.kind === "minimum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createLessThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
             else if (tag.kind === "maximum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createGreaterThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
             else if (tag.kind === "exclusiveMinimum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createLessThan(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
             else if (tag.kind === "exclusiveMaximum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createGreaterThan(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
+                ]);
+
+        return {
+            expression: is_number(project, numeric)(metaTags)(input),
+            tags: [
+                ...entries.map(([tag, expression]) => ({
+                    expected: `number (@${tag.kind} ${tag.value})`,
+                    expression,
+                })),
+                ...check_custom("number")(importer)(jsDocTag)(input),
+            ],
+        };
+    };
+
+const is_number =
+    ({ options }: IProject, numeric: boolean) =>
+    (metaTags: IMetadataTag[]) =>
+    (input: ts.Expression) => {
+        // TYPEOF STATEMENT
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("number"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // CHECK FINITE AND NAN
+        const finite: boolean =
+            (!!metaTags.find(
+                (tag) =>
+                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
+            ) &&
+                !!metaTags.find(
+                    (tag) =>
+                        tag.kind === "maximum" ||
+                        tag.kind === "exclusiveMaximum",
+                )) ||
+            !!metaTags.find(
+                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
+            );
+
+        if (numeric === true && finite === false)
+            if (OptionPredicator.finite(options))
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Number.isFinite"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (OptionPredicator.numeric(options))
+                conditions.push(
+                    ts.factory.createLogicalNot(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [input],
+                        ),
+                    ),
                 );
 
-        // COMBINATION
+        // COMBINATE
         return conditions.length === 1
             ? conditions[0]!
             : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));

package/src/programmers/internal/check_string.ts

@@ -3,22 +3,23 @@ import ts from "typescript";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_custom } from "./check_custom";
 import { check_string_tags } from "./check_string_tags";
 
 /**
  * @internal
  */
-export function check_string(importer: FunctionImporter) {
-    return function (input: ts.Expression, tagList: IMetadataTag[]) {
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-            ...check_string_tags(importer)(input, tagList),
-        ];
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
-}
+export const check_string =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: ts.JSDocTagInfo[]) =>
+    (input: ts.Expression) => ({
+        expression: ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("string"),
+            ts.factory.createTypeOfExpression(input),
+        ),
+        tags: [
+            ...check_string_tags(importer)(metaTags)(input),
+            ...check_custom("string")(importer)(jsDocTags)(input),
+        ],
+    });

package/src/programmers/internal/check_string_tags.ts

@@ -5,17 +5,20 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 /**
  * @internal
  */
 export const check_string_tags =
     (importer: FunctionImporter) =>
-    (input: ts.Expression, tagList: IMetadataTag[]) => {
-        const conditions: ts.Expression[] = [];
+    (tagList: IMetadataTag[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] => {
+        const conditions: [IMetadataTag, ts.Expression][] = [];
         for (const tag of tagList)
             if (tag.kind === "format")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createTrue(),
                         ts.factory.createCallExpression(
@@ -24,9 +27,10 @@ export const check_string_tags =
                             [input],
                         ),
                     ),
-                );
+                ]);
             else if (tag.kind === "pattern")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createTrue(),
                         ts.factory.createCallExpression(
@@ -37,27 +41,33 @@ export const check_string_tags =
                             [input],
                         ),
                     ),
-                );
+                ]);
             else if (tag.kind === "length")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(tag.value),
                         IdentifierFactory.join(input, "length"),
                     ),
-                );
+                ]);
             else if (tag.kind === "minLength")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createLessThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         IdentifierFactory.join(input, "length"),
                     ),
-                );
+                ]);
             else if (tag.kind === "maxLength")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createGreaterThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         IdentifierFactory.join(input, "length"),
                     ),
-                );
-        return conditions;
+                ]);
+        return conditions.map(([tag, expression]) => ({
+            expected: `string (@${tag.kind} ${tag.value})`,
+            expression,
+        }));
     };

package/src/programmers/internal/check_template.ts

@@ -1,9 +1,12 @@
 import ts from "typescript";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
 import { check_string_tags } from "./check_string_tags";
 import { template_to_pattern } from "./template_to_pattern";
 
@@ -12,18 +15,16 @@ import { template_to_pattern } from "./template_to_pattern";
  */
 export const check_template =
     (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        templates: Metadata[][],
-        tagList: IMetadataTag[],
-    ) => {
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (templates: Metadata[][]) =>
+    (input: ts.Expression): ICheckEntry => {
         // TYPEOF STRING & TAGS
         const conditions: ts.Expression[] = [
             ts.factory.createStrictEquality(
                 ts.factory.createStringLiteral("string"),
                 ts.factory.createTypeOfExpression(input),
             ),
-            ...check_string_tags(importer)(input, tagList),
         ];
 
         // TEMPLATES
@@ -46,5 +47,13 @@ export const check_template =
         );
 
         // COMBINATION
-        return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+        return {
+            expression: conditions.reduce((x, y) =>
+                ts.factory.createLogicalAnd(x, y),
+            ),
+            tags: [
+                ...check_string_tags(importer)(metaTags)(input),
+                ...check_custom("string")(importer)(jsDocTags)(input),
+            ],
+        };
     };

package/src/programmers/internal/check_union_array_like.ts

@@ -18,6 +18,7 @@ export const check_union_array_like =
         targets: T[],
         explore: FeatureProgrammer.IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
     ) => {
         // ONLY ONE TYPE
         if (targets.length === 1)
@@ -26,6 +27,7 @@ export const check_union_array_like =
                 targets[0]!,
                 explore,
                 tags,
+                jsDocTags,
             );
 
         //----
@@ -58,6 +60,7 @@ export const check_union_array_like =
                                         postfix: `"[0]"`,
                                     },
                                     tags,
+                                    jsDocTags,
                                     input,
                                 ),
                             ),
@@ -80,6 +83,7 @@ export const check_union_array_like =
                                         tracable: true,
                                     },
                                     tags,
+                                    jsDocTags,
                                 ),
                             ),
                         ]),
@@ -239,6 +243,7 @@ export namespace check_union_array_like {
             target: T,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
             array: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<T>;

package/src/programmers/internal/check_union_tuple.ts

@@ -23,6 +23,7 @@ export const check_union_tuple =
         elements: Metadata[],
         explore: CheckerProgrammer.IExplore,
         tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
         array: ts.Expression,
     ) =>
         CheckerProgrammer.decode_tuple(project, config, importer, true)(
@@ -30,4 +31,5 @@ export const check_union_tuple =
             elements,
             explore,
             tags,
+            jsDocTags,
         );

package/src/programmers/internal/feature_object_entries.ts

@@ -54,6 +54,7 @@ export const feature_object_entries =
                                   })(),
                     },
                     prop.tags,
+                    prop.jsDocTags,
                 ),
             };
         });

package/src/transformers/CallExpressionTransformer.ts

@@ -28,7 +28,6 @@ import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransf
 import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
 import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
 import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
-import { MessageTransformer } from "./features/protocols/MessageTransformer";
 import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
 import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
 import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
@@ -95,7 +94,7 @@ const CLI_PATH = path.resolve(
 
 const FUNCTORS: Record<string, () => Task> = {
     //----
-    // VALIDATORS
+    // SINGLE FUNCTIONS
     //----
     // BASIC VALIDATORS
     assert: () => AssertTransformer.transform(false),
@@ -108,23 +107,13 @@ const FUNCTORS: Record<string, () => Task> = {
     equals: () => IsTransformer.transform(true),
     validateEquals: () => ValidateTransformer.transform(true),
 
-    //----
-    // PROTOCOL BUFFER
-    //----
-    message: () => MessageTransformer.transform,
-
-    //----
-    // JSON FUNCTIONS
-    //----
-    // SCHEMA DEFINITION
-    application: () => ApplicationTransformer.transform,
-
-    // PARSER FUNCTIONS
+    // PARSE FUNCTIONS
     isParse: () => IsParseTransformer.transform,
     assertParse: () => AssertParseTransformer.transform,
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
+    application: () => ApplicationTransformer.transform,
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
@@ -147,19 +136,23 @@ const FUNCTORS: Record<string, () => Task> = {
     //----
     // FACTORY FUNCTIONS
     //----
-    // VALIDATORS
+    // BASIC VALIDATORS
     createAssert: () => CreateAssertTransformer.transform(false),
     createAssertType: () => CreateAssertTransformer.transform(false),
     createIs: () => CreateIsTransformer.transform(false),
     createValidate: () => CreateValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
     createAssertEquals: () => CreateAssertTransformer.transform(true),
     createEquals: () => CreateIsTransformer.transform(true),
     createValidateEquals: () => CreateValidateTransformer.transform(true),
 
-    // JSON FUNCTIONS
+    // PARSE FUNCTIONS
     createIsParse: () => CreateIsParseTransformer.transform,
     createAssertParse: () => CreateAssertParseTransformer.transform,
     createValidateParse: () => CreateValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
     createStringify: () => CreateStringifyTransformer.transform,
     createAssertStringify: () => CreateAssertStringifyTransformer.transform,
     createIsStringify: () => CreateIsStringifyTransformer.transform,

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -59,7 +59,9 @@ export namespace ApplicationTransformer {
         // GENERATORS
         //----
         // METADATA
-        const collection: MetadataCollection = new MetadataCollection();
+        const collection: MetadataCollection = new MetadataCollection({
+            replace: MetadataCollection.replace,
+        });
         const metadatas: Array<Metadata> = types.map((type) =>
             MetadataFactory.generate(checker, collection, type, {
                 resolve: true,

package/src/transformers/features/miscellaneous/CreateRandomGenerator.ts

@@ -32,7 +32,7 @@ export namespace CreateRandomTransformer {
                 },
             },
             modulo,
-        )(type, node.getText());
+        )(type, node.getFullText().trim());
     }
 }
 

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -33,7 +33,7 @@ export namespace RandomTransformer {
                     },
                 },
                 modulo,
-            )(type, node.getText()),
+            )(type, node.getFullText().trim()),
             undefined,
             expression.arguments.length
                 ? [expression.arguments[0]!]

package/src/transformers/internal/GenericTransformer.ts

@@ -47,7 +47,7 @@ export namespace GenericTransformer {
                 programmer(project, modulo)(
                     type,
                     generic
-                        ? node.getText()
+                        ? node.getFullText().trim()
                         : name(project.checker)(type)(node),
                 ),
                 undefined,
@@ -84,7 +84,7 @@ export namespace GenericTransformer {
                 );
 
             // DO TRANSFORM
-            return programmer(project, modulo)(type, node.getText());
+            return programmer(project, modulo)(type, node.getFullText().trim());
         };
 
     const name =

package/src/typings/Customizable.ts

@@ -0,0 +1,6 @@
+export type Customizable = {
+    number: number;
+    string: string;
+    bigint: bigint;
+    array: any[];
+};

package/src/utils/RandomGenerator.ts

@@ -84,7 +84,13 @@ export namespace RandomGenerator {
 
     export function date(min?: number, max?: number): string {
         min ??= 0;
-        max ??= Date.now();
-        return new Date(number(min, max)).toString();
+        max ??= Date.now() * 2;
+        return new Date(number(min, max)).toISOString().substring(0, 10);
+    }
+
+    export function datetime(min?: number, max?: number): string {
+        min ??= 0;
+        max ??= Date.now() * 2;
+        return new Date(number(min, max)).toISOString();
     }
 }

package/lib/factories/ProtocolFactory.d.ts

@@ -1,8 +0,0 @@
-import ts from "typescript";
-import { Metadata } from "../metadata/Metadata";
-import { IProtocolMessage } from "../messages/IProtocolMessage";
-import { MetadataCollection } from "./MetadataCollection";
-export declare namespace ProtocolFactory {
-    const metadata: (checker: ts.TypeChecker) => (collection: MetadataCollection) => (type: ts.Type) => Metadata;
-    const generate: (collection: MetadataCollection) => (dict: Map<string, IProtocolMessage>) => (meta: Metadata) => void;
-}