typia 5.2.4-dev.20231023 → 5.2.5-dev.20231105

package/src/programmers/internal/check_dynamic_key.ts

@@ -0,0 +1,178 @@
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_bigint } from "./check_bigint";
+import { check_number } from "./check_number";
+import { check_string } from "./check_string";
+import { check_template } from "./check_template";
+
+export const check_dynamic_key =
+    (project: IProject) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, metadata: Metadata): ts.Expression => {
+        // IF PURE STRING EXISTS, THEN SKIP VALIDATION
+        if (
+            (metadata.atomics.length !== 0 &&
+                metadata.atomics.some(
+                    (a) =>
+                        a.type === "string" &&
+                        a.tags.filter((row) =>
+                            row.every((t) => t.validate !== undefined),
+                        ).length === 0,
+                )) ||
+            (metadata.natives.length !== 0 &&
+                metadata.natives.some((type) => type === "String"))
+        )
+            return ts.factory.createTrue();
+
+        const conditions: ts.Expression[] = [];
+
+        // NULLISH COALESCING
+        if (metadata.nullable === true)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("null"),
+                    input,
+                ),
+            );
+        if (metadata.isRequired() === false)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("undefined"),
+                    input,
+                ),
+            );
+
+        // ATOMICS
+        for (const atom of metadata.atomics)
+            if (atom.type === "boolean")
+                conditions.push(
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("false"),
+                            input,
+                        ),
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("true"),
+                            input,
+                        ),
+                    ),
+                );
+            else if (atom.type === "bigint")
+                conditions.push(
+                    ts.factory.createLogicalAnd(
+                        ts.factory.createCallExpression(
+                            importer.use("is_bigint_string"),
+                            undefined,
+                            [input],
+                        ),
+                        atomist(
+                            check_bigint(project)(atom)(
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("BigInt"),
+                                    undefined,
+                                    [input],
+                                ),
+                            ),
+                        ),
+                    ),
+                );
+            else if (atom.type === "number")
+                conditions.push(
+                    atomist(
+                        check_number(project, true)(atom)(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("Number"),
+                                undefined,
+                                [input],
+                            ),
+                        ),
+                    ),
+                );
+            else conditions.push(atomist(check_string(project)(atom)(input)));
+
+        // CONSTANTS
+        for (const constant of metadata.constants)
+            for (const value of constant.values)
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createStringLiteral(String(value)),
+                        input,
+                    ),
+                );
+
+        // TEMPLATES
+        if (!!metadata.templates.length)
+            conditions.push(atomist(check_template(metadata.templates)(input)));
+
+        // NATIVES
+        for (const native of metadata.natives)
+            if (native === "Boolean")
+                conditions.push(
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("false"),
+                            input,
+                        ),
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("true"),
+                            input,
+                        ),
+                    ),
+                );
+            else if (native === "BigInt")
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        importer.use("is_bigint_string"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (native === "Number")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createFalse(),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("Number"),
+                                    undefined,
+                                    [input],
+                                ),
+                            ],
+                        ),
+                    ),
+                );
+
+        return conditions.length === 0
+            ? ts.factory.createTrue()
+            : conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce(ts.factory.createLogicalOr);
+    };
+
+const atomist = (entry: ICheckEntry) => {
+    return [
+        ...(entry.expression ? [entry.expression] : []),
+        ...(entry.conditions.length === 0
+            ? []
+            : [
+                  entry.conditions
+                      .map((set) =>
+                          set
+                              .map((s) => s.expression)
+                              .reduce((a, b) =>
+                                  ts.factory.createLogicalAnd(a, b),
+                              ),
+                      )
+                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+              ]),
+    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+};

package/src/programmers/internal/check_dynamic_properties.ts

@@ -3,17 +3,20 @@ import ts from "typescript";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 
+import { IProject } from "../../transformers/IProject";
+
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_key } from "./check_dynamic_key";
 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) =>
+    (project: IProject) =>
     (importer: FunctionImporter) =>
     (
         input: ts.Expression,
@@ -64,7 +67,11 @@ export const check_dynamic_properties =
                       undefined,
                       [input],
                   ),
-                  check_dynamic_property(props)(input, regular, dynamic),
+                  check_dynamic_property(props)(project)(importer)(
+                      input,
+                      regular,
+                      dynamic,
+                  ),
               ])
             : ts.factory.createCallExpression(
                   IdentifierFactory.access(
@@ -75,7 +82,13 @@ export const check_dynamic_properties =
                       ),
                   )(props.assert ? "every" : "map"),
                   undefined,
-                  [check_dynamic_property(props)(input, regular, dynamic)],
+                  [
+                      check_dynamic_property(props)(project)(importer)(
+                          input,
+                          regular,
+                          dynamic,
+                      ),
+                  ],
               );
         const right: ts.Expression = (props.halt || ((elem) => elem))(
             props.assert ? criteria : check_everything(criteria),
@@ -89,6 +102,8 @@ export const check_dynamic_properties =
 
 const check_dynamic_property =
     (props: check_object.IProps) =>
+    (project: IProject) =>
+    (importer: FunctionImporter) =>
     (
         input: ts.Expression,
         regular: IExpressionEntry<ts.Expression>[],
@@ -129,15 +144,7 @@ const check_dynamic_property =
 
         for (const entry of dynamic)
             add(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        `RegExp(/${metadata_to_pattern(true)(
-                            entry.key,
-                        )}/).test`,
-                    ),
-                    undefined,
-                    [key],
-                ),
+                check_dynamic_key(project)(importer)(key, entry.key),
                 entry.expression,
             );
 

package/src/programmers/internal/check_object.ts

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { IProject } from "../../transformers/IProject";
+
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_properties } from "./check_dynamic_properties";
@@ -10,6 +12,7 @@ import { check_everything } from "./check_everything";
  */
 export const check_object =
     (props: check_object.IProps) =>
+    (project: IProject) =>
     (importer: FunctionImporter) =>
     (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
         // PREPARE ASSETS
@@ -23,7 +26,11 @@ export const check_object =
 
         // CHECK DYNAMIC PROPERTIES
         flags.push(
-            check_dynamic_properties(props)(importer)(input, regular, dynamic),
+            check_dynamic_properties(props)(project)(importer)(
+                input,
+                regular,
+                dynamic,
+            ),
         );
         return reduce(props)(flags);
     };

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -905,7 +905,7 @@ export namespace JsonStringifyProgrammer {
                     decoder: () => decode_object(importer),
                     joiner: StringifyJoiner.object(importer),
                     unionizer: decode_union_object(
-                        IsProgrammer.decode_object(importer),
+                        IsProgrammer.decode_object(project)(importer),
                     )(decode_object(importer))((exp) => exp)(
                         (value, expected) =>
                             create_throw_error(importer)(expected)(value),