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

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;

package/src/programmers/internal/check_array.ts

@@ -2,21 +2,25 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 import { check_array_length } from "./check_array_length";
+import { check_custom } from "./check_custom";
 
 /**
  * @internal
  */
-export function check_array(
-    input: ts.Expression,
-    tagList: IMetadataTag[],
-): ts.Expression {
-    const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
-
-    const length: ts.Expression | null = check_array_length(input, tagList);
-    if (length !== null) conditions.push(length);
-
-    return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-}
+export const check_array =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => ({
+        expression: ExpressionFactory.isArray(input),
+        tags: [
+            ...check_array_length(metaTags)(input),
+            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
+        ],
+    });

package/src/programmers/internal/check_array_length.ts

@@ -4,41 +4,37 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
 /**
  * @internal
  */
-export function check_array_length(
-    input: ts.Expression,
-    tagList: IMetadataTag[],
-): ts.Expression | null {
-    const conditions: ts.Expression[] = [];
-
-    // CHECK TAGS
-    for (const tag of tagList)
-        if (tag.kind === "items")
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "minItems")
-            conditions.push(
-                ts.factory.createLessThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "maxItems")
-            conditions.push(
-                ts.factory.createGreaterThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-
-    // COMBINATION
-    return conditions.length
-        ? conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y))
-        : null;
-}
+export const check_array_length =
+    (tagList: IMetadataTag[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] =>
+        tagList
+            .map((tag) => ({
+                tag,
+                expression:
+                    tag.kind === "items"
+                        ? ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(tag.value),
+                              IdentifierFactory.join(input, "length"),
+                          )
+                        : tag.kind === "minItems"
+                        ? ts.factory.createLessThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              IdentifierFactory.join(input, "length"),
+                          )
+                        : tag.kind === "maxItems"
+                        ? ts.factory.createGreaterThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              IdentifierFactory.join(input, "length"),
+                          )
+                        : null!,
+            }))
+            .filter((tuple) => tuple.expression !== null)
+            .map(({ tag, expression }) => ({
+                expected: `Array.length (@${tag.kind} ${tag.value})`,
+                expression,
+            }));

package/src/programmers/internal/check_bigint.ts

@@ -1,64 +1,82 @@
 import ts from "typescript";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
-export function check_bigint(input: ts.Expression, tagList: IMetadataTag[]) {
-    const caster = (value: number) =>
-        ts.factory.createIdentifier(`${Math.floor(value)}n`);
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
 
-    // TYPEOF STATEMENT
-    const conditions: ts.Expression[] = [
-        ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("bigint"),
-            ts.factory.createTypeOfExpression(input),
-        ),
-    ];
+/**
+ * @internal
+ */
+export const check_bigint =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTag: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => {
+        const entries: [IMetadataTag, ts.Expression][] = [];
+        for (const tag of metaTags) {
+            if (tag.kind === "multipleOf")
+                entries.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        cast(0),
+                        ts.factory.createModulo(input, cast(tag.value)),
+                    ),
+                ]);
+            else if (tag.kind === "step") {
+                const modulo = ts.factory.createModulo(input, cast(tag.value));
+                const minimum =
+                    (metaTags.find(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    )?.value as number | undefined) ?? undefined;
+                entries.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        cast(0),
+                        minimum !== undefined
+                            ? ts.factory.createSubtract(modulo, cast(minimum))
+                            : modulo,
+                    ),
+                ]);
+            } else if (tag.kind === "minimum")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThanEquals(cast(tag.value), input),
+                ]);
+            else if (tag.kind === "maximum")
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThanEquals(cast(tag.value), input),
+                ]);
+            else if (tag.kind === "exclusiveMinimum")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThan(cast(tag.value), input),
+                ]);
+            else if (tag.kind === "exclusiveMaximum")
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThan(cast(tag.value), input),
+                ]);
+        }
+        return {
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("bigint"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            tags: [
+                ...entries.map(([tag, expression]) => ({
+                    expected: `bigint (@${tag.kind} ${tag.value})`,
+                    expression,
+                })),
+                ...check_custom("bigint")(importer)(jsDocTag)(input),
+            ],
+        };
+    };
 
-    // TAG (RANGE)
-    for (const tag of tagList)
-        if (tag.kind === "multipleOf")
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    caster(0),
-                    ts.factory.createModulo(input, caster(tag.value)),
-                ),
-            );
-        else if (tag.kind === "step") {
-            const modulo = () =>
-                ts.factory.createModulo(input, caster(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(
-                ts.factory.createStrictEquality(
-                    caster(0),
-                    minimum !== undefined
-                        ? ts.factory.createSubtract(modulo(), caster(minimum))
-                        : modulo(),
-                ),
-            );
-        } else if (tag.kind === "minimum")
-            conditions.push(
-                ts.factory.createLessThanEquals(caster(tag.value), input),
-            );
-        else if (tag.kind === "maximum")
-            conditions.push(
-                ts.factory.createGreaterThanEquals(caster(tag.value), input),
-            );
-        else if (tag.kind === "exclusiveMinimum")
-            conditions.push(
-                ts.factory.createLessThan(caster(tag.value), input),
-            );
-        else if (tag.kind === "exclusiveMaximum")
-            conditions.push(
-                ts.factory.createGreaterThan(caster(tag.value), input),
-            );
-
-    // COMBINATION
-    return conditions.length === 1
-        ? conditions[0]!
-        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-}
+const cast = (value: number) =>
+    ts.factory.createIdentifier(`${Math.floor(value)}n`);

package/src/programmers/internal/check_custom.ts

@@ -0,0 +1,41 @@
+import ts from "typescript";
+
+import { MetadataTagFactory } from "../../factories/MetadataTagFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+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,
+                        ],
+                    ),
+                };
+            });