typia 3.8.0-dev.20230420-2 → 3.8.0-dev.20230426

package/src/programmers/helpers/PruneJoiner.ts

@@ -6,22 +6,34 @@ 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,
+        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(
-            entries.map((entry) =>
+            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);
     };
@@ -50,3 +62,83 @@ export namespace PruneJoiner {
         return ts.factory.createBlock(statements, true);
     };
 }
+
+const iterate_dynamic_properties =
+    (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
+    (input: ts.Expression) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.join(
+                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/internal/application_schema.ts

@@ -26,7 +26,11 @@ export const application_schema =
         attribute: IJsonSchema.IAttribute,
     ): BlockNever extends true ? IJsonSchema | null : IJsonSchema => {
         // VULNERABLE CASE
-        if (meta.any === true) return {};
+        if (meta.any === true)
+            return {
+                ...attribute,
+                type: undefined,
+            };
         else if (meta.nullable && meta.empty())
             return { type: "null", ...attribute };
 
@@ -173,7 +177,13 @@ export const application_schema =
         //----
         // RETURNS
         //----
-        if (union.length === 0) return blockNever === true ? null! : {};
+        if (union.length === 0)
+            return blockNever === true
+                ? null!
+                : {
+                      ...attribute,
+                      type: undefined,
+                  };
         else if (union.length === 1) return union[0]!;
         return { oneOf: union, ...attribute };
     };

package/src/programmers/internal/check_custom.ts

@@ -1,31 +1,31 @@
-import ts from "typescript";
-
-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[] =>
-        get_comment_tags(true)(jsDocTags).map((tag) => ({
-            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,
-                ],
-            ),
-        }));
+import ts from "typescript";
+
+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[] =>
+        get_comment_tags(true)(jsDocTags).map((tag) => ({
+            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_dynamic_properties.ts

@@ -1,194 +1,194 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_everything } from "./check_everything";
-import { check_object } from "./check_object";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const check_dynamic_properties =
-    (props: check_object.IProps) =>
-    (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        regular: IExpressionEntry<ts.Expression>[],
-        dynamic: IExpressionEntry<ts.Expression>[],
-    ): ts.Expression => {
-        const length = IdentifierFactory.access(
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.keys"),
-                undefined,
-                [input],
-            ),
-        )("length");
-        const left: ts.Expression | null =
-            props.equals === true && dynamic.length === 0
-                ? props.undefined === true ||
-                  regular.every((r) => r.meta.required)
-                    ? ts.factory.createStrictEquality(
-                          ts.factory.createNumericLiteral(
-                              regular.filter((r) => r.meta.required).length,
-                          ),
-                          length,
-                      )
-                    : ts.factory.createCallExpression(
-                          importer.use("is_between"),
-                          [],
-                          [
-                              length,
-                              ts.factory.createNumericLiteral(
-                                  regular.filter((r) => r.meta.required).length,
-                              ),
-                              ts.factory.createNumericLiteral(regular.length),
-                          ],
-                      )
-                : null;
-        if (
-            props.undefined === false &&
-            left !== null &&
-            regular.every((r) => r.meta.required)
-        )
-            return left;
-
-        const criteria = props.entries
-            ? ts.factory.createCallExpression(props.entries, undefined, [
-                  ts.factory.createCallExpression(
-                      ts.factory.createIdentifier("Object.keys"),
-                      undefined,
-                      [input],
-                  ),
-                  check_dynamic_property(props)(input, regular, dynamic),
-              ])
-            : ts.factory.createCallExpression(
-                  IdentifierFactory.access(
-                      ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("Object.keys"),
-                          undefined,
-                          [input],
-                      ),
-                  )(props.assert ? "every" : "map"),
-                  undefined,
-                  [check_dynamic_property(props)(input, regular, dynamic)],
-              );
-        const right: ts.Expression = (props.halt || ((elem) => elem))(
-            props.assert ? criteria : check_everything(criteria),
-        );
-        return left
-            ? (props.undefined
-                  ? ts.factory.createLogicalOr
-                  : ts.factory.createLogicalAnd)(left, right)
-            : right;
-    };
-
-const check_dynamic_property =
-    (props: check_object.IProps) =>
-    (
-        input: ts.Expression,
-        regular: IExpressionEntry<ts.Expression>[],
-        dynamic: IExpressionEntry<ts.Expression>[],
-    ) => {
-        //----
-        // IF CONDITIONS
-        //----
-        // PREPARE ASSETS
-        const key = ts.factory.createIdentifier("key");
-        const value = ts.factory.createIdentifier("value");
-
-        const statements: ts.Statement[] = [];
-        const add = (exp: ts.Expression, output: ts.Expression) =>
-            statements.push(
-                ts.factory.createIfStatement(
-                    exp,
-                    ts.factory.createReturnStatement(output),
-                ),
-            );
-
-        // GATHER CONDITIONS
-        if (props.equals === true && regular.length)
-            add(is_regular_property(regular), props.positive);
-        statements.push(
-            StatementFactory.constant(
-                "value",
-                ts.factory.createElementAccessExpression(input, key),
-            ),
-        );
-        if (props.undefined === true)
-            add(
-                ts.factory.createStrictEquality(
-                    ts.factory.createIdentifier("undefined"),
-                    value,
-                ),
-                props.positive,
-            );
-
-        for (const entry of dynamic)
-            add(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        `RegExp(/${metadata_to_pattern(true)(
-                            entry.key,
-                        )}/).test`,
-                    ),
-                    undefined,
-                    [key],
-                ),
-                entry.expression,
-            );
-
-        //----
-        // FUNCTION BODY
-        //----
-        // CLOSURE BLOCK
-        const block: ts.Block = ts.factory.createBlock(
-            [
-                ...statements,
-                ts.factory.createReturnStatement(
-                    props.equals === true
-                        ? props.superfluous(value)
-                        : props.positive,
-                ),
-            ],
-            true,
-        );
-
-        // RETURNS
-        return ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [IdentifierFactory.parameter("key")],
-            undefined,
-            undefined,
-            block,
-        );
-    };
-
-const is_regular_property = (regular: IExpressionEntry[]) =>
-    ts.factory.createCallExpression(
-        IdentifierFactory.access(
-            ts.factory.createArrayLiteralExpression(
-                regular.map((entry) =>
-                    ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
-                ),
-            ),
-        )("some"),
-        undefined,
-        [
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("prop")],
-                undefined,
-                undefined,
-                ts.factory.createStrictEquality(
-                    ts.factory.createIdentifier("key"),
-                    ts.factory.createIdentifier("prop"),
-                ),
-            ),
-        ],
-    );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_everything } from "./check_everything";
+import { check_object } from "./check_object";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_dynamic_properties =
+    (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
+    (
+        input: ts.Expression,
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
+    ): ts.Expression => {
+        const length = IdentifierFactory.access(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.keys"),
+                undefined,
+                [input],
+            ),
+        )("length");
+        const left: ts.Expression | null =
+            props.equals === true && dynamic.length === 0
+                ? props.undefined === true ||
+                  regular.every((r) => r.meta.required)
+                    ? ts.factory.createStrictEquality(
+                          ts.factory.createNumericLiteral(
+                              regular.filter((r) => r.meta.required).length,
+                          ),
+                          length,
+                      )
+                    : ts.factory.createCallExpression(
+                          importer.use("is_between"),
+                          [],
+                          [
+                              length,
+                              ts.factory.createNumericLiteral(
+                                  regular.filter((r) => r.meta.required).length,
+                              ),
+                              ts.factory.createNumericLiteral(regular.length),
+                          ],
+                      )
+                : null;
+        if (
+            props.undefined === false &&
+            left !== null &&
+            regular.every((r) => r.meta.required)
+        )
+            return left;
+
+        const criteria = props.entries
+            ? ts.factory.createCallExpression(props.entries, undefined, [
+                  ts.factory.createCallExpression(
+                      ts.factory.createIdentifier("Object.keys"),
+                      undefined,
+                      [input],
+                  ),
+                  check_dynamic_property(props)(input, regular, dynamic),
+              ])
+            : ts.factory.createCallExpression(
+                  IdentifierFactory.access(
+                      ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("Object.keys"),
+                          undefined,
+                          [input],
+                      ),
+                  )(props.assert ? "every" : "map"),
+                  undefined,
+                  [check_dynamic_property(props)(input, regular, dynamic)],
+              );
+        const right: ts.Expression = (props.halt || ((elem) => elem))(
+            props.assert ? criteria : check_everything(criteria),
+        );
+        return left
+            ? (props.undefined
+                  ? ts.factory.createLogicalOr
+                  : ts.factory.createLogicalAnd)(left, right)
+            : right;
+    };
+
+const check_dynamic_property =
+    (props: check_object.IProps) =>
+    (
+        input: ts.Expression,
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
+    ) => {
+        //----
+        // IF CONDITIONS
+        //----
+        // PREPARE ASSETS
+        const key = ts.factory.createIdentifier("key");
+        const value = ts.factory.createIdentifier("value");
+
+        const statements: ts.Statement[] = [];
+        const add = (exp: ts.Expression, output: ts.Expression) =>
+            statements.push(
+                ts.factory.createIfStatement(
+                    exp,
+                    ts.factory.createReturnStatement(output),
+                ),
+            );
+
+        // GATHER CONDITIONS
+        if (props.equals === true && regular.length)
+            add(is_regular_property(regular), props.positive);
+        statements.push(
+            StatementFactory.constant(
+                "value",
+                ts.factory.createElementAccessExpression(input, key),
+            ),
+        );
+        if (props.undefined === true)
+            add(
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("undefined"),
+                    value,
+                ),
+                props.positive,
+            );
+
+        for (const entry of dynamic)
+            add(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        `RegExp(/${metadata_to_pattern(true)(
+                            entry.key,
+                        )}/).test`,
+                    ),
+                    undefined,
+                    [key],
+                ),
+                entry.expression,
+            );
+
+        //----
+        // FUNCTION BODY
+        //----
+        // CLOSURE BLOCK
+        const block: ts.Block = ts.factory.createBlock(
+            [
+                ...statements,
+                ts.factory.createReturnStatement(
+                    props.equals === true
+                        ? props.superfluous(value)
+                        : props.positive,
+                ),
+            ],
+            true,
+        );
+
+        // RETURNS
+        return ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("key")],
+            undefined,
+            undefined,
+            block,
+        );
+    };
+
+const is_regular_property = (regular: IExpressionEntry[]) =>
+    ts.factory.createCallExpression(
+        IdentifierFactory.access(
+            ts.factory.createArrayLiteralExpression(
+                regular.map((entry) =>
+                    ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
+                ),
+            ),
+        )("some"),
+        undefined,
+        [
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("prop")],
+                undefined,
+                undefined,
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("key"),
+                    ts.factory.createIdentifier("prop"),
+                ),
+            ),
+        ],
+    );