typia 3.7.0 → 3.7.1-dev.20230406

package/src/factories/MetadataTagFactory.ts

@@ -51,8 +51,8 @@ export namespace MetadataTagFactory {
         ) => IMetadataTag | null
     > = {
         /* -----------------------------------------------------------
-        ARRAY
-    ----------------------------------------------------------- */
+            ARRAY
+        ----------------------------------------------------------- */
         items: (identifier, metadata, text, output) => {
             validate(identifier, metadata, output, "items", "array", [
                 "minItems",
@@ -82,8 +82,8 @@ export namespace MetadataTagFactory {
         },
 
         /* -----------------------------------------------------------
-        NUMBER
-    ----------------------------------------------------------- */
+            NUMBER
+        ----------------------------------------------------------- */
         type: (identifier, metadata, text, output) => {
             validate(identifier, metadata, output, "type", "number", []);
             if (text !== "int" && text !== "uint")
@@ -168,8 +168,8 @@ export namespace MetadataTagFactory {
         },
 
         /* -----------------------------------------------------------
-        STRING
-    ----------------------------------------------------------- */
+            STRING
+        ----------------------------------------------------------- */
         format: (identifier, metadata, str, output) => {
             validate(identifier, metadata, output, "format", "string", [
                 "pattern",

package/src/metadata/ICommentTag.ts

@@ -0,0 +1,4 @@
+export interface ICommentTag {
+    name: string;
+    value?: string;
+}

package/src/programmers/RandomProgrammer.ts

@@ -8,6 +8,7 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TemplateFactory } from "../factories/TemplateFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 
+import { ICommentTag } from "../metadata/ICommentTag";
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
 
@@ -16,11 +17,13 @@ import { IProject } from "../transformers/IProject";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { RandomJoiner } from "./helpers/RandomJoiner";
 import { RandomRanger } from "./helpers/RandomRanger";
+import { random_custom } from "./internal/random_custom";
 
 export namespace RandomProgrammer {
     export function generate(
         project: IProject,
         modulo: ts.LeftHandSideExpression,
+        init?: ts.Expression,
     ) {
         const importer: FunctionImporter = new FunctionImporter();
         return (type: ts.Type, name?: string) => {
@@ -42,7 +45,7 @@ export namespace RandomProgrammer {
             const output: ts.Expression = decode(importer)({
                 object: false,
                 recursive: false,
-            })(meta, []);
+            })(meta, [], []);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -53,15 +56,8 @@ export namespace RandomProgrammer {
                         ts.factory.createTypeReferenceNode(
                             "Partial<typia.IRandomGenerator>",
                         ),
-                        IdentifierFactory.join(
-                            ts.factory.createParenthesizedExpression(
-                                ts.factory.createAsExpression(
-                                    modulo,
-                                    TypeFactory.keyword("any"),
-                                ),
-                            ),
-                            "generator",
-                        ),
+                        init ??
+                            ts.factory.createToken(ts.SyntaxKind.QuestionToken),
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
@@ -122,7 +118,11 @@ export namespace RandomProgrammer {
     const decode =
         (importer: FunctionImporter) =>
         (explore: IExplore) =>
-        (meta: Metadata, tags: IMetadataTag[]): ts.Expression => {
+        (
+            meta: Metadata,
+            tags: IMetadataTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
             const expressions: ts.Expression[] = [];
             if (meta.any)
                 expressions.push(
@@ -137,35 +137,41 @@ export namespace RandomProgrammer {
             if (meta.nullable === true)
                 expressions.push(ts.factory.createNull());
 
-            // ATOMIC TYPES
+            // CONSTANT TYPES
             for (const constant of meta.constants)
                 for (const value of constant.values)
                     expressions.push(decode_atomic(value));
+
+            // ATOMIC VARIABLES
             for (const template of meta.templates)
                 expressions.push(decode_template(importer)(explore)(template));
             for (const atomic of meta.atomics)
                 if (atomic === "boolean")
                     expressions.push(decode_boolean(importer));
                 else if (atomic === "number")
-                    expressions.push(decode_number(importer)(tags));
+                    expressions.push(decode_number(importer)(tags)(comments));
                 else if (atomic === "string")
-                    expressions.push(decode_string(importer)(tags));
+                    expressions.push(decode_string(importer)(tags)(comments));
                 else if (atomic === "bigint")
-                    expressions.push(decode_bigint(importer)(tags));
+                    expressions.push(decode_bigint(importer)(tags)(comments));
 
             // INSTANCE TYPES
             if (meta.resolved)
                 expressions.push(
-                    decode(importer)(explore)(meta.resolved, tags),
+                    decode(importer)(explore)(meta.resolved, tags, comments),
                 );
             for (const t of meta.tuples)
                 expressions.push(
-                    RandomJoiner.tuple(decode(importer)(explore))(t, tags),
+                    RandomJoiner.tuple(decode(importer)(explore))(
+                        t,
+                        tags,
+                        comments,
+                    ),
                 );
             for (const a of meta.arrays) {
                 const array = RandomJoiner.array(COALESCE(importer))(
                     decode(importer)(explore),
-                )(a, tags);
+                )(a, tags, comments);
                 expressions.push(
                     explore.recursive && a.objects.length
                         ? ts.factory.createConditionalExpression(
@@ -214,9 +220,9 @@ export namespace RandomProgrammer {
                 if (native === "Boolean")
                     expressions.push(decode_boolean(importer));
                 else if (native === "Number")
-                    expressions.push(decode_number(importer)(tags));
+                    expressions.push(decode_number(importer)(tags)(comments));
                 else if (native === "String")
-                    expressions.push(decode_string(importer)(tags));
+                    expressions.push(decode_string(importer)(tags)(comments));
                 else expressions.push(ts.factory.createIdentifier("{}"));
             if (meta.sets.length || meta.maps.length)
                 expressions.push(ts.factory.createIdentifier("{}"));
@@ -269,12 +275,13 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (template: Metadata[]) =>
             TemplateFactory.generate(
-                template.map((meta) => decode(importer)(explore)(meta, [])),
+                template.map((meta) => decode(importer)(explore)(meta, [], [])),
             );
 
     const decode_number =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[]): ts.Expression => {
+        (tags: IMetadataTag[]) =>
+        (comments: ICommentTag[]): ts.Expression => {
             const type = tags.find(
                 (t) => t.kind === "type" && t.value === "uint",
             )
@@ -282,96 +289,110 @@ export namespace RandomProgrammer {
                 : tags.find((t) => t.kind === "type" && t.value === "int")
                 ? "uint"
                 : "double";
-            return RandomRanger.number({
-                type,
-                transform: (value) => ts.factory.createNumericLiteral(value),
-                setter: (args) =>
-                    ts.factory.createCallExpression(
-                        type === "double" &&
-                            tags.every(
-                                (t) =>
-                                    t.kind !== "multipleOf" &&
-                                    t.kind !== "step",
-                            )
-                            ? COALESCE(importer)("number")
-                            : COALESCE(importer)("integer"),
-                        undefined,
-                        args.map((val) => ts.factory.createNumericLiteral(val)),
-                    ),
-            })({
-                minimum: 0,
-                maximum: 100,
-                gap: 10,
-            })(tags);
+            return random_custom(COALESCE(importer))("number")(comments)(
+                RandomRanger.number({
+                    type,
+                    transform: (value) =>
+                        ts.factory.createNumericLiteral(value),
+                    setter: (args) =>
+                        ts.factory.createCallExpression(
+                            type === "double" &&
+                                tags.every(
+                                    (t) =>
+                                        t.kind !== "multipleOf" &&
+                                        t.kind !== "step",
+                                )
+                                ? COALESCE(importer)("number")
+                                : COALESCE(importer)("integer"),
+                            undefined,
+                            args.map((val) =>
+                                ts.factory.createNumericLiteral(val),
+                            ),
+                        ),
+                })({
+                    minimum: 0,
+                    maximum: 100,
+                    gap: 10,
+                })(tags),
+            );
         };
 
     const decode_bigint =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[]): ts.Expression =>
-            RandomRanger.number({
-                type: tags.find((t) => t.kind === "type" && t.value === "uint")
-                    ? "uint"
-                    : "int",
-                transform: (value) =>
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("BigInt"),
-                        undefined,
-                        [ts.factory.createStringLiteral(value.toString())],
-                    ),
-                setter: (args) =>
-                    ts.factory.createCallExpression(
-                        COALESCE(importer)("bigint"),
-                        undefined,
-                        args.map((value) =>
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("BigInt"),
-                                undefined,
-                                [
-                                    ts.factory.createStringLiteral(
-                                        value.toString(),
-                                    ),
-                                ],
+        (tags: IMetadataTag[]) =>
+        (comments: ICommentTag[]): ts.Expression =>
+            random_custom(COALESCE(importer))("bigint")(comments)(
+                RandomRanger.number({
+                    type: tags.find(
+                        (t) => t.kind === "type" && t.value === "uint",
+                    )
+                        ? "uint"
+                        : "int",
+                    transform: (value) =>
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("BigInt"),
+                            undefined,
+                            [ts.factory.createStringLiteral(value.toString())],
+                        ),
+                    setter: (args) =>
+                        ts.factory.createCallExpression(
+                            COALESCE(importer)("bigint"),
+                            undefined,
+                            args.map((value) =>
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("BigInt"),
+                                    undefined,
+                                    [
+                                        ts.factory.createStringLiteral(
+                                            value.toString(),
+                                        ),
+                                    ],
+                                ),
                             ),
                         ),
-                    ),
-            })({
-                minimum: 0,
-                maximum: 100,
-                gap: 10,
-            })(tags);
+                })({
+                    minimum: 0,
+                    maximum: 100,
+                    gap: 10,
+                })(tags),
+            );
 
     const decode_string =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[]): ts.Expression => {
-            for (const t of tags)
-                if (t.kind === "format")
-                    return ts.factory.createCallExpression(
-                        COALESCE(importer)(t.value),
-                        undefined,
-                        undefined,
-                    );
-                else if (t.kind === "pattern")
+        (tags: IMetadataTag[]) =>
+        (comments: ICommentTag[]): ts.Expression =>
+            random_custom(COALESCE(importer))("string")(comments)(
+                (() => {
+                    for (const t of tags)
+                        if (t.kind === "format")
+                            return ts.factory.createCallExpression(
+                                COALESCE(importer)(t.value),
+                                undefined,
+                                undefined,
+                            );
+                        else if (t.kind === "pattern")
+                            return ts.factory.createCallExpression(
+                                COALESCE(importer)("pattern"),
+                                undefined,
+                                [ts.factory.createIdentifier(`/${t.value}/`)],
+                            );
+
+                    const tail = RandomRanger.length(COALESCE(importer))({
+                        minimum: 5,
+                        maximum: 25,
+                        gap: 5,
+                    })({
+                        fixed: "length",
+                        minimum: "minLength",
+                        maximum: "maxLength",
+                    })(tags);
                     return ts.factory.createCallExpression(
-                        COALESCE(importer)("pattern"),
+                        COALESCE(importer)("string"),
                         undefined,
-                        [ts.factory.createIdentifier(`/${t.value}/`)],
+                        tail ? [tail] : undefined,
                     );
-
-            const tail = RandomRanger.length(COALESCE(importer))({
-                minimum: 5,
-                maximum: 25,
-                gap: 5,
-            })({
-                fixed: "length",
-                minimum: "minLength",
-                maximum: "maxLength",
-            })(tags);
-            return ts.factory.createCallExpression(
-                COALESCE(importer)("string"),
-                undefined,
-                tail ? [tail] : undefined,
+                })(),
             );
-        };
 }
 
 type Atomic = boolean | number | string | bigint;
@@ -383,6 +404,10 @@ interface IExplore {
 const FUNCTOR = (i: number) => `$ro${i}`;
 const COALESCE = (importer: FunctionImporter) => (name: string) =>
     ExpressionFactory.coalesce(
-        ts.factory.createIdentifier(`generator.${name}`),
+        ts.factory.createPropertyAccessChain(
+            ts.factory.createIdentifier("generator"),
+            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+            ts.factory.createIdentifier(name),
+        ),
         IdentifierFactory.join(importer.use("generator"), name),
     );

package/src/programmers/helpers/RandomJoiner.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
+import { ICommentTag } from "../../metadata/ICommentTag";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
 import { MetadataObject } from "../../metadata/MetadataObject";
@@ -10,18 +11,20 @@ import { MetadataProperty } from "../../metadata/MetadataProperty";
 
 import { Escaper } from "../../utils/Escaper";
 
+import { get_comment_tags } from "../internal/get_comment_tags";
 import { RandomRanger } from "./RandomRanger";
 
 export namespace RandomJoiner {
     export type Decoder = (
         meta: Metadata,
         tags: IMetadataTag[],
+        comments: ICommentTag[],
     ) => ts.Expression;
 
     export const array =
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
-        (item: Metadata, tags: IMetadataTag[]) => {
+        (item: Metadata, tags: IMetadataTag[], comments: ICommentTag[]) => {
             const tail = RandomRanger.length(coalesce)({
                 minimum: 0,
                 maximum: 3,
@@ -41,7 +44,7 @@ export namespace RandomJoiner {
                         [],
                         undefined,
                         undefined,
-                        decoder(item, tags),
+                        decoder(item, tags, comments),
                     ),
                     ...(tail ? [tail] : []),
                 ],
@@ -49,9 +52,10 @@ export namespace RandomJoiner {
         };
 
     export const tuple =
-        (decoder: Decoder) => (items: Metadata[], tags: IMetadataTag[]) =>
+        (decoder: Decoder) =>
+        (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
             ts.factory.createArrayLiteralExpression(
-                items.map((i) => decoder(i.rest ?? i, tags)),
+                items.map((i) => decoder(i.rest ?? i, tags, comments)),
                 true,
             );
 
@@ -77,7 +81,11 @@ export namespace RandomJoiner {
                             Escaper.variable(str)
                                 ? str
                                 : ts.factory.createStringLiteral(str),
-                            decoder(p.value, p.tags),
+                            decoder(
+                                p.value,
+                                p.tags,
+                                get_comment_tags(false)(p.jsDocTags),
+                            ),
                         );
                     }),
                     true,
@@ -131,10 +139,14 @@ export namespace RandomJoiner {
                     ts.factory.createBinaryExpression(
                         ts.factory.createElementAccessExpression(
                             ts.factory.createIdentifier("output"),
-                            decoder(p.key, []),
+                            decoder(p.key, [], []),
                         ),
                         ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                        decoder(p.value, p.tags),
+                        decoder(
+                            p.value,
+                            p.tags,
+                            get_comment_tags(false)(p.jsDocTags),
+                        ),
                     ),
                 ),
                 ts.factory.createCallExpression(

package/src/programmers/helpers/RandomRanger.ts

@@ -13,7 +13,7 @@ export namespace RandomRanger {
         (coalesce: (method: string) => ts.Expression) =>
         (defs: IDefaults) =>
         (acc: length.IAccessors) =>
-        (tags: IMetadataTag[]) => {
+        (tags: IMetadataTag[]): ts.Expression | undefined => {
             const props = {
                 fixed: getter(tags)(acc.fixed),
                 minimum: getter(tags)(acc.minimum),

package/src/programmers/internal/application_native.ts

@@ -3,6 +3,9 @@ import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../module";
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 
+/**
+ * @internal
+ */
 export const application_native =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>

package/src/programmers/internal/check_array.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
@@ -20,7 +21,10 @@ export const check_array =
     (input: ts.Expression): ICheckEntry => ({
         expression: ExpressionFactory.isArray(input),
         tags: [
-            ...check_array_length(metaTags)(input),
+            ...check_array_length(metaTags)(
+                IdentifierFactory.join(input, "length"),
+            ),
             ...check_custom("array", "Array")(importer)(jsDocTags)(input),
+            // check custom array for legacy (3.7.0)
         ],
     });

package/src/programmers/internal/check_array_length.ts

@@ -1,35 +1,30 @@
 import ts from "typescript";
 
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
 /**
  * @internal
  */
 export const check_array_length =
-    (tagList: IMetadataTag[]) =>
-    (input: ts.Expression): ICheckEntry.ITag[] =>
-        tagList
+    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
+        metaTags
             .map((tag) => ({
                 tag,
                 expression:
                     tag.kind === "items"
                         ? ts.factory.createStrictEquality(
                               ts.factory.createNumericLiteral(tag.value),
-                              IdentifierFactory.join(input, "length"),
+                              input,
                           )
                         : tag.kind === "minItems"
                         ? ts.factory.createLessThanEquals(
                               ts.factory.createNumericLiteral(tag.value),
-                              IdentifierFactory.join(input, "length"),
+                              input,
                           )
                         : tag.kind === "maxItems"
                         ? ts.factory.createGreaterThanEquals(
                               ts.factory.createNumericLiteral(tag.value),
-                              IdentifierFactory.join(input, "length"),
+                              input,
                           )
                         : null!,
             }))

package/src/programmers/internal/check_custom.ts

@@ -1,41 +1,33 @@
 import ts from "typescript";
 
-import { MetadataTagFactory } from "../../factories/MetadataTagFactory";
-
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
+import { get_comment_tags } from "./get_comment_tags";
 
+/**
+ * @internal
+ */
 export const check_custom =
     (type: string, alias?: string) =>
     (importer: FunctionImporter) =>
     (jsDocTags: IJsDocTagInfo[]) =>
     (input: ts.Expression): ICheckEntry.ITag[] =>
-        jsDocTags
-            .filter(
-                (tag) =>
-                    tag.name !== "random" &&
-                    (!tag.text?.length ||
-                        (tag.text?.length === 1 &&
-                            tag.text?.[0]?.kind === "text")) &&
-                    MetadataTagFactory._PARSER[tag.name] === undefined,
-            )
-            .map((tag) => {
-                const text: string | undefined = tag.text?.[0]?.text ?? "";
-                return {
-                    expected: `${alias ?? type} (@${tag.name}${
-                        text.length ? ` ${text}` : ""
-                    })`,
-                    expression: ts.factory.createCallExpression(
-                        importer.use("is_custom"),
-                        undefined,
-                        [
-                            ts.factory.createStringLiteral(tag.name),
-                            ts.factory.createStringLiteral(type),
-                            ts.factory.createStringLiteral(text),
-                            input,
-                        ],
-                    ),
-                };
-            });
+        get_comment_tags(true)(jsDocTags).map((tag) => {
+            return {
+                expected: `${alias ?? type} (@${tag.name}${
+                    tag.value?.length ? ` ${tag.value}` : ""
+                })`,
+                expression: ts.factory.createCallExpression(
+                    importer.use("is_custom"),
+                    undefined,
+                    [
+                        ts.factory.createStringLiteral(tag.name),
+                        ts.factory.createStringLiteral(type),
+                        ts.factory.createStringLiteral(tag.value ?? ""),
+                        input,
+                    ],
+                ),
+            };
+        });

package/src/programmers/internal/check_number.ts

@@ -120,6 +120,9 @@ export const check_number =
         };
     };
 
+/**
+ * @internal
+ */
 const is_number =
     ({ options }: IProject, numeric: boolean) =>
     (metaTags: IMetadataTag[]) =>

package/src/programmers/internal/check_object.ts

@@ -27,6 +27,10 @@ export const check_object =
         );
         return reduce(props)(flags);
     };
+
+/**
+ * @internal
+ */
 export namespace check_object {
     export interface IProps {
         equals: boolean;
@@ -40,6 +44,9 @@ export namespace check_object {
     }
 }
 
+/**
+ * @internal
+ */
 const reduce = (props: check_object.IProps) => (expressions: ts.Expression[]) =>
     props.assert
         ? expressions.reduce(props.reduce)

package/src/programmers/internal/check_union_array_like.ts

@@ -10,6 +10,9 @@ import { CheckerProgrammer } from "../CheckerProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { UnionExplorer } from "../helpers/UnionExplorer";
 
+/**
+ * @internal
+ */
 export const check_union_array_like =
     <T>(accessor: check_union_array_like.IAccessor<T>) =>
     (props: check_union_array_like.IProps<T>) =>
@@ -236,6 +239,10 @@ export const check_union_array_like =
             undefined,
         );
     };
+
+/**
+ * @internal
+ */
 export namespace check_union_array_like {
     export interface IProps<T> {
         checker(