typia 4.0.10-dev.20230615 → 4.0.10-dev.20230616

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,143 +1,143 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../metadata/MetadataObject";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { prune_object_properties } from "../internal/prune_object_properties";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace PruneJoiner {
-    export const object = (
-        input: ts.Expression,
-        entries: IExpressionEntry[],
-        obj: MetadataObject,
-    ): ts.ConciseBody => {
-        // PREPARE ASSETS
-        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
-
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            regular.map((entry) =>
-                ts.isBlock(entry.expression)
-                    ? [...entry.expression.statements]
-                    : [ts.factory.createExpressionStatement(entry.expression)],
-            ),
-        );
-        if (dynamic.length)
-            statements.push(
-                ts.factory.createExpressionStatement(
-                    iterate_dynamic_properties({ regular, dynamic })(input),
-                ),
-            );
-
-        statements.push(prune_object_properties(obj));
-        return ts.factory.createBlock(statements, true);
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("forEach"),
-            undefined,
-            [arrow],
-        );
-
-    export const tuple = (
-        children: ts.ConciseBody[],
-        rest: ts.ConciseBody | null,
-    ): ts.Block => {
-        const entire: ts.ConciseBody[] = [...children];
-        if (rest !== null) entire.push(rest);
-
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            entire.map((elem) =>
-                ts.isBlock(elem)
-                    ? [...elem.statements]
-                    : [ts.factory.createExpressionStatement(elem)],
-            ),
-        );
-        return ts.factory.createBlock(statements, true);
-    };
-}
-
-const iterate_dynamic_properties =
-    (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
-    (input: ts.Expression) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.access(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [input],
-                ),
-            )("forEach"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                        IdentifierFactory.parameter(
-                            ts.factory.createArrayBindingPattern(
-                                ["key", "value"].map((l) =>
-                                    ts.factory.createBindingElement(
-                                        undefined,
-                                        undefined,
-                                        ts.factory.createIdentifier(l),
-                                        undefined,
-                                    ),
-                                ),
-                            ),
-                        ),
-                    ],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(
-                        [
-                            ts.factory.createIfStatement(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createIdentifier("undefined"),
-                                    ts.factory.createIdentifier("value"),
-                                ),
-                                ts.factory.createReturnStatement(),
-                            ),
-                            ...props.regular.map(({ key }) =>
-                                ts.factory.createIfStatement(
-                                    ts.factory.createStrictEquality(
-                                        ts.factory.createStringLiteral(
-                                            key.getSoleLiteral()!,
-                                        ),
-                                        ts.factory.createIdentifier("key"),
-                                    ),
-                                    ts.factory.createReturnStatement(),
-                                ),
-                            ),
-                            ...props.dynamic.map((dynamic) =>
-                                ts.factory.createIfStatement(
-                                    ts.factory.createCallExpression(
-                                        ts.factory.createIdentifier(
-                                            `RegExp(/${metadata_to_pattern(
-                                                true,
-                                            )(dynamic.key)}/).test`,
-                                        ),
-                                        undefined,
-                                        [ts.factory.createIdentifier("key")],
-                                    ),
-                                    ts.isBlock(dynamic.expression)
-                                        ? dynamic.expression
-                                        : ts.factory.createBlock([
-                                              ts.factory.createExpressionStatement(
-                                                  dynamic.expression,
-                                              ),
-                                          ]),
-                                ),
-                            ),
-                        ],
-                        true,
-                    ),
-                ),
-            ],
-        );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { prune_object_properties } from "../internal/prune_object_properties";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace PruneJoiner {
+    export const object = (
+        input: ts.Expression,
+        entries: IExpressionEntry[],
+        obj: MetadataObject,
+    ): ts.ConciseBody => {
+        // PREPARE ASSETS
+        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            regular.map((entry) =>
+                ts.isBlock(entry.expression)
+                    ? [...entry.expression.statements]
+                    : [ts.factory.createExpressionStatement(entry.expression)],
+            ),
+        );
+        if (dynamic.length)
+            statements.push(
+                ts.factory.createExpressionStatement(
+                    iterate_dynamic_properties({ regular, dynamic })(input),
+                ),
+            );
+
+        statements.push(prune_object_properties(obj));
+        return ts.factory.createBlock(statements, true);
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.access(input)("forEach"),
+            undefined,
+            [arrow],
+        );
+
+    export const tuple = (
+        children: ts.ConciseBody[],
+        rest: ts.ConciseBody | null,
+    ): ts.Block => {
+        const entire: ts.ConciseBody[] = [...children];
+        if (rest !== null) entire.push(rest);
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            entire.map((elem) =>
+                ts.isBlock(elem)
+                    ? [...elem.statements]
+                    : [ts.factory.createExpressionStatement(elem)],
+            ),
+        );
+        return ts.factory.createBlock(statements, true);
+    };
+}
+
+const iterate_dynamic_properties =
+    (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
+    (input: ts.Expression) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [input],
+                ),
+            )("forEach"),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [
+                        IdentifierFactory.parameter(
+                            ts.factory.createArrayBindingPattern(
+                                ["key", "value"].map((l) =>
+                                    ts.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        ts.factory.createIdentifier(l),
+                                        undefined,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(
+                        [
+                            ts.factory.createIfStatement(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createIdentifier("undefined"),
+                                    ts.factory.createIdentifier("value"),
+                                ),
+                                ts.factory.createReturnStatement(),
+                            ),
+                            ...props.regular.map(({ key }) =>
+                                ts.factory.createIfStatement(
+                                    ts.factory.createStrictEquality(
+                                        ts.factory.createStringLiteral(
+                                            key.getSoleLiteral()!,
+                                        ),
+                                        ts.factory.createIdentifier("key"),
+                                    ),
+                                    ts.factory.createReturnStatement(),
+                                ),
+                            ),
+                            ...props.dynamic.map((dynamic) =>
+                                ts.factory.createIfStatement(
+                                    ts.factory.createCallExpression(
+                                        ts.factory.createIdentifier(
+                                            `RegExp(/${metadata_to_pattern(
+                                                true,
+                                            )(dynamic.key)}/).test`,
+                                        ),
+                                        undefined,
+                                        [ts.factory.createIdentifier("key")],
+                                    ),
+                                    ts.isBlock(dynamic.expression)
+                                        ? dynamic.expression
+                                        : ts.factory.createBlock([
+                                              ts.factory.createExpressionStatement(
+                                                  dynamic.expression,
+                                              ),
+                                          ]),
+                                ),
+                            ),
+                        ],
+                        true,
+                    ),
+                ),
+            ],
+        );

package/src/programmers/helpers/StringifyPredicator.ts

@@ -6,7 +6,7 @@ export namespace StringifyPredicator {
 
     export const undefindable = (meta: Metadata): boolean =>
         meta.required === false ||
-        (meta.resolved !== null && meta.resolved.required === false);
+        (meta.resolved !== null && meta.resolved.returns.required === false);
 
     const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
 }

package/src/programmers/internal/application_resolved.ts

@@ -0,0 +1,55 @@
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataResolved } from "../../metadata/MetadataResolved";
+
+import { IJsonComponents, IJsonSchema } from "../../module";
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+export const application_resolved =
+    (options: ApplicationProgrammer.IOptions) =>
+    <BlockNever extends boolean>(blockNever: BlockNever) =>
+    (components: IJsonComponents) =>
+    (resolved: MetadataResolved) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema[] => {
+        const output = application_schema(options)(blockNever)(components)(
+            resolved.returns,
+        )(attribute);
+        if (output === null) return [];
+
+        if (is_date(new Set())(resolved.original)) {
+            const string: IJsonSchema.IString | undefined = is_string(output)
+                ? output
+                : is_one_of(output)
+                ? output.oneOf.find(is_string)
+                : undefined;
+            if (
+                string !== undefined &&
+                string.format !== "date" &&
+                string.format !== "date-time"
+            )
+                string.format = "date-time";
+        }
+        return is_one_of(output) ? output.oneOf : [output];
+    };
+
+const is_string = (elem: IJsonSchema): elem is IJsonSchema.IString =>
+    (elem as IJsonSchema.IString).type === "string";
+
+const is_one_of = (elem: IJsonSchema): elem is IJsonSchema.IOneOf =>
+    Array.isArray((elem as IJsonSchema.IOneOf).oneOf);
+
+const is_date =
+    (visited: Set<Metadata>) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.natives.some((name) => name === "Date") ||
+            meta.arrays.some((array) => is_date(visited)(array.value)) ||
+            meta.tuples.some((tuple) =>
+                tuple.elements.some(is_date(visited)),
+            ) ||
+            meta.aliases.some((alias) => is_date(visited)(alias.value))
+        );
+    };

package/src/programmers/internal/application_schema.ts

@@ -11,6 +11,7 @@ import { application_constant } from "./application_constant";
 import { application_native } from "./application_native";
 import { application_number } from "./application_number";
 import { application_object } from "./application_object";
+import { application_resolved } from "./application_resolved";
 import { application_string } from "./application_string";
 import { application_templates } from "./application_templates";
 import { application_tuple } from "./application_tuple";
@@ -57,12 +58,12 @@ export const application_schema =
                 : (schema: IJsonSchema) => union.push(schema);
 
         // toJSON() METHOD
-        if (meta.resolved !== null) {
-            const resolved = application_schema(options)(blockNever)(
-                components,
-            )(meta.resolved)(attribute);
-            if (resolved !== null) union.push(resolved);
-        }
+        if (meta.resolved !== null)
+            union.push(
+                ...application_resolved(options)(blockNever)(components)(
+                    meta.resolved,
+                )(attribute),
+            );
 
         // ATOMIC TYPES
         if (meta.templates.length && AtomicPredicator.template(meta))

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

@@ -33,7 +33,7 @@ export namespace MetadataTransformer {
             const collection: MetadataCollection = new MetadataCollection();
             const metadatas: Array<Metadata> = types.map((type) =>
                 MetadataFactory.analyze(checker)({
-                    resolve: false,
+                    resolve: true,
                     constant: true,
                     absorb: true,
                 })(collection)(type),