typia 3.4.24 → 3.4.25

package/src/programmers/AssertProgrammer.ts

@@ -4,6 +4,7 @@ import { IdentifierFactory } from "../factories/IdentifierFactory";
 
 // import { StatementFactory } from "../factories/StatementFactory";
 import { IProject } from "../transformers/IProject";
+import { ITransformOptions } from "../transformers/ITransformOptions";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
@@ -240,8 +241,8 @@ export namespace AssertProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
-                    combiner: combiner(equals)(importer),
-                    joiner: joiner(equals)(importer),
+                    combiner: combiner(project.options)(equals)(importer),
+                    joiner: joiner(project.options)(equals)(importer),
                     success: ts.factory.createTrue(),
                 },
                 importer,
@@ -277,14 +278,15 @@ export namespace AssertProgrammer {
         };
 
     const combiner =
+        (options: ITransformOptions) =>
         (equals: boolean) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
         (explore: CheckerProgrammer.IExplore) => {
             if (explore.tracable === false)
                 return IsProgrammer.CONFIG({
-                    object: assert_object(equals)(importer),
+                    object: assert_object(options)(equals)(importer),
                     numeric: true,
-                }).combiner(explore);
+                })(importer).combiner(explore);
 
             const path: string = explore.postfix
                 ? `path + ${explore.postfix}`
@@ -350,39 +352,44 @@ export namespace AssertProgrammer {
             //   );
         };
 
-    const assert_object = (equals: boolean) => (importer: FunctionImporter) =>
-        check_object({
-            equals,
-            assert: true,
-            reduce: ts.factory.createLogicalAnd,
-            positive: ts.factory.createTrue(),
-            superfluous: (value) =>
-                create_guard_call(importer)()(
-                    ts.factory.createAdd(
-                        ts.factory.createIdentifier("path"),
-                        ts.factory.createCallExpression(
-                            importer.use("join"),
-                            undefined,
-                            [ts.factory.createIdentifier("key")],
+    const assert_object =
+        (options: ITransformOptions) =>
+        (equals: boolean) =>
+        (importer: FunctionImporter) =>
+            check_object({
+                equals,
+                assert: true,
+                undefined: OptionPredicator.undefined(options),
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: (value) =>
+                    create_guard_call(importer)()(
+                        ts.factory.createAdd(
+                            ts.factory.createIdentifier("path"),
+                            ts.factory.createCallExpression(
+                                importer.use("join"),
+                                undefined,
+                                [ts.factory.createIdentifier("key")],
+                            ),
                         ),
+                        "undefined",
+                        value,
                     ),
-                    "undefined",
-                    value,
-                ),
-            halt: (expr) =>
-                ts.factory.createLogicalOr(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createIdentifier("exceptionable"),
+                halt: (expr) =>
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createFalse(),
+                            ts.factory.createIdentifier("exceptionable"),
+                        ),
+                        expr,
                     ),
-                    expr,
-                ),
-        });
+            })(importer);
 
     const joiner =
+        (options: ITransformOptions) =>
         (equals: boolean) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-            object: assert_object(equals)(importer),
+            object: assert_object(options)(equals)(importer),
             array: (input, arrow) =>
                 ts.factory.createCallExpression(
                     IdentifierFactory.join(input, "every"),

package/src/programmers/IsProgrammer.ts

@@ -16,60 +16,64 @@ import { check_object } from "./internal/check_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
 export namespace IsProgrammer {
-    export const CONFIG = (
-        options?: Partial<CONFIG.IOptions>,
-    ): CheckerProgrammer.IConfig => ({
-        functors: "$io",
-        unioners: "$iu",
-        trace: false,
-        path: false,
-        equals: !!options?.object,
-        numeric: OptionPredicator.numeric({
-            numeric: options?.numeric,
-        }),
-        combiner: () => (type: "and" | "or") => {
-            const initial: ts.TrueLiteral | ts.FalseLiteral =
-                type === "and"
-                    ? ts.factory.createTrue()
-                    : ts.factory.createFalse();
-            const binder =
-                type === "and"
-                    ? ts.factory.createLogicalAnd
-                    : ts.factory.createLogicalOr;
-            return (
-                _input: ts.Expression,
-                binaries: CheckerProgrammer.IBinary[],
-            ) =>
-                binaries.length
-                    ? binaries
-                          .map((binary) => binary.expression)
-                          .reduce((x, y) => binder(x, y))
-                    : initial;
-        },
-        joiner: {
-            object:
-                options?.object ||
-                check_object({
-                    equals: !!options?.object,
-                    assert: true,
-                    reduce: ts.factory.createLogicalAnd,
-                    positive: ts.factory.createTrue(),
-                    superfluous: () => ts.factory.createFalse(),
-                }),
-            array: (input, arrow) =>
-                ts.factory.createCallExpression(
-                    IdentifierFactory.join(input, "every"),
-                    undefined,
-                    [arrow],
-                ),
-            failure: () => ts.factory.createFalse(),
-        },
-        success: ts.factory.createTrue(),
-    });
+    export const CONFIG =
+        (options?: Partial<CONFIG.IOptions>) =>
+        (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
+            functors: "$io",
+            unioners: "$iu",
+            trace: false,
+            path: false,
+            equals: !!options?.object,
+            numeric: OptionPredicator.numeric({
+                numeric: options?.numeric,
+            }),
+            combiner: () => (type: "and" | "or") => {
+                const initial: ts.TrueLiteral | ts.FalseLiteral =
+                    type === "and"
+                        ? ts.factory.createTrue()
+                        : ts.factory.createFalse();
+                const binder =
+                    type === "and"
+                        ? ts.factory.createLogicalAnd
+                        : ts.factory.createLogicalOr;
+                return (
+                    _input: ts.Expression,
+                    binaries: CheckerProgrammer.IBinary[],
+                ) =>
+                    binaries.length
+                        ? binaries
+                              .map((binary) => binary.expression)
+                              .reduce((x, y) => binder(x, y))
+                        : initial;
+            },
+            joiner: {
+                object:
+                    options?.object ||
+                    check_object({
+                        equals: !!options?.object,
+                        undefined: OptionPredicator.undefined({
+                            undefined: options?.undefined,
+                        }),
+                        assert: true,
+                        reduce: ts.factory.createLogicalAnd,
+                        positive: ts.factory.createTrue(),
+                        superfluous: () => ts.factory.createFalse(),
+                    })(importer),
+                array: (input, arrow) =>
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(input, "every"),
+                        undefined,
+                        [arrow],
+                    ),
+                failure: () => ts.factory.createFalse(),
+            },
+            success: ts.factory.createTrue(),
+        });
 
     export namespace CONFIG {
         export interface IOptions {
             numeric: boolean;
+            undefined: boolean;
             object: (entries: IExpressionEntry[]) => ts.Expression;
         }
     }
@@ -88,13 +92,14 @@ export namespace IsProgrammer {
         const config = CONFIG({
             object: check_object({
                 equals,
+                undefined: OptionPredicator.undefined(project.options),
                 assert: true,
                 reduce: ts.factory.createLogicalAnd,
                 positive: ts.factory.createTrue(),
                 superfluous: () => ts.factory.createFalse(),
-            }),
+            })(importer),
             numeric: OptionPredicator.numeric(project.options),
-        });
+        })(importer);
         config.trace = equals;
 
         if (equals === false)
@@ -137,21 +142,31 @@ export namespace IsProgrammer {
     export const generate_functors = (
         project: IProject,
         importer: FunctionImporter,
-    ) => CheckerProgrammer.generate_functors(project, CONFIG(), importer);
+    ) =>
+        CheckerProgrammer.generate_functors(
+            project,
+            CONFIG()(importer),
+            importer,
+        );
 
     export const generate_unioners = (
         project: IProject,
         importer: FunctionImporter,
-    ) => CheckerProgrammer.generate_unioners(project, CONFIG(), importer);
+    ) =>
+        CheckerProgrammer.generate_unioners(
+            project,
+            CONFIG()(importer),
+            importer,
+        );
 
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     export const decode = (project: IProject, importer: FunctionImporter) =>
-        CheckerProgrammer.decode(project, CONFIG(), importer);
+        CheckerProgrammer.decode(project, CONFIG()(importer), importer);
 
-    export const decode_object = () =>
-        CheckerProgrammer.decode_object(CONFIG());
+    export const decode_object = (importer: FunctionImporter) =>
+        CheckerProgrammer.decode_object(CONFIG()(importer));
 
     export function decode_to_json(input: ts.Expression): ts.Expression {
         return ts.factory.createLogicalAnd(

package/src/programmers/StringifyProgrammer.ts

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

package/src/programmers/ValidateProgrammer.ts

@@ -4,6 +4,7 @@ import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
 
 import { IProject } from "../transformers/IProject";
+import { ITransformOptions } from "../transformers/ITransformOptions";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
@@ -30,8 +31,8 @@ export namespace ValidateProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
-                    combiner: combine(equals)(importer),
-                    joiner: joiner(equals)(importer),
+                    combiner: combine(project.options)(equals)(importer),
+                    joiner: joiner(project.options)(equals)(importer),
                     success: ts.factory.createTrue(),
                 },
                 importer,
@@ -85,14 +86,15 @@ export namespace ValidateProgrammer {
 }
 
 const combine =
+    (options: ITransformOptions) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
         if (explore.tracable === false)
             return IsProgrammer.CONFIG({
-                object: validate_object(equals)(importer),
+                object: validate_object(options)(equals)(importer),
                 numeric: true,
-            }).combiner(explore);
+            })(importer).combiner(explore);
 
         const path: string = explore.postfix
             ? `path + ${explore.postfix}`
@@ -131,39 +133,44 @@ const combine =
                   );
     };
 
-const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
-    check_object({
-        equals,
-        assert: false,
-        reduce: ts.factory.createLogicalAnd,
-        positive: ts.factory.createTrue(),
-        superfluous: (value) =>
-            create_report_call()(
-                ts.factory.createAdd(
-                    ts.factory.createIdentifier("path"),
-                    ts.factory.createCallExpression(
-                        importer.use("join"),
-                        undefined,
-                        [ts.factory.createIdentifier("key")],
+const validate_object =
+    (options: ITransformOptions) =>
+    (equals: boolean) =>
+    (importer: FunctionImporter) =>
+        check_object({
+            equals,
+            undefined: OptionPredicator.undefined(options),
+            assert: false,
+            reduce: ts.factory.createLogicalAnd,
+            positive: ts.factory.createTrue(),
+            superfluous: (value) =>
+                create_report_call()(
+                    ts.factory.createAdd(
+                        ts.factory.createIdentifier("path"),
+                        ts.factory.createCallExpression(
+                            importer.use("join"),
+                            undefined,
+                            [ts.factory.createIdentifier("key")],
+                        ),
                     ),
+                    "undefined",
+                    value,
                 ),
-                "undefined",
-                value,
-            ),
-        halt: (expr) =>
-            ts.factory.createLogicalOr(
-                ts.factory.createStrictEquality(
-                    ts.factory.createFalse(),
-                    ts.factory.createIdentifier("exceptionable"),
+            halt: (expr) =>
+                ts.factory.createLogicalOr(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createFalse(),
+                        ts.factory.createIdentifier("exceptionable"),
+                    ),
+                    expr,
                 ),
-                expr,
-            ),
-    });
+        })(importer);
 
 const joiner =
+    (options: ITransformOptions) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-        object: validate_object(equals)(importer),
+        object: validate_object(options)(equals)(importer),
         array: (input, arrow) =>
             check_everything(
                 ts.factory.createCallExpression(

package/src/programmers/helpers/OptionPredicator.ts

@@ -12,4 +12,8 @@ export namespace OptionPredicator {
     export function finite(options: ITransformOptions): boolean {
         return options.finite === true;
     }
+
+    export function undefined(options: ITransformOptions): boolean {
+        return options.undefined !== false;
+    }
 }

package/src/programmers/internal/check_dynamic_properties.ts

@@ -3,6 +3,7 @@ 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";
@@ -13,26 +14,47 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  */
 export const check_dynamic_properties =
     (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
     (
         regular: IExpressionEntry[],
         dynamic: IExpressionEntry[],
     ): ts.Expression => {
-        const length =
+        const length = IdentifierFactory.join(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.keys"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+            ),
+            "length",
+        );
+        const left: ts.Expression | null =
             props.equals === true && dynamic.length === 0
-                ? ts.factory.createStrictEquality(
-                      ts.factory.createNumericLiteral(
-                          regular.filter((r) => r.meta.required).length,
-                      ),
-                      IdentifierFactory.join(
-                          ts.factory.createCallExpression(
-                              ts.factory.createIdentifier("Object.keys"),
-                              undefined,
-                              [ts.factory.createIdentifier("input")],
+                ? props.undefined === true ||
+                  regular.every((r) => r.meta.required)
+                    ? ts.factory.createStrictEquality(
+                          ts.factory.createNumericLiteral(
+                              regular.filter((r) => r.meta.required).length,
                           ),
-                          "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, [
@@ -58,7 +80,11 @@ export const check_dynamic_properties =
         const right: ts.Expression = (props.halt || ((elem) => elem))(
             props.assert ? criteria : check_everything(criteria),
         );
-        return length ? ts.factory.createLogicalOr(length, right) : right;
+        return left
+            ? (props.undefined
+                  ? ts.factory.createLogicalOr
+                  : ts.factory.createLogicalAnd)(left, right)
+            : right;
     };
 
 const check_dynamic_property =
@@ -89,13 +115,14 @@ const check_dynamic_property =
                 ts.factory.createIdentifier("input[key]"),
             ),
         );
-        add(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                value,
-            ),
-            props.positive,
-        );
+        if (props.undefined === true)
+            add(
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("undefined"),
+                    value,
+                ),
+                props.positive,
+            );
         for (const entry of dynamic)
             add(
                 ts.factory.createCallExpression(

package/src/programmers/internal/check_object.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_properties } from "./check_dynamic_properties";
 import { check_everything } from "./check_everything";
@@ -8,7 +9,9 @@ import { check_everything } from "./check_everything";
  * @internal
  */
 export const check_object =
-    (props: check_object.IProps) => (entries: IExpressionEntry[]) => {
+    (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
+    (entries: IExpressionEntry[]) => {
         // PREPARE ASSETS
         const regular = entries.filter((entry) => entry.key.isSoleLiteral());
         const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
@@ -19,13 +22,14 @@ export const check_object =
             return regular.length === 0 ? props.positive : reduce(props)(flags);
 
         // CHECK DYNAMIC PROPERTIES
-        flags.push(check_dynamic_properties(props)(regular, dynamic));
+        flags.push(check_dynamic_properties(props)(importer)(regular, dynamic));
         return reduce(props)(flags);
     };
 export namespace check_object {
     export interface IProps {
         equals: boolean;
         assert: boolean;
+        undefined: boolean;
         halt?: (exp: ts.Expression) => ts.Expression;
         reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
         positive: ts.Expression;

package/src/transformers/ITransformOptions.ts

@@ -44,4 +44,15 @@ export interface ITransformOptions {
      * @default false
      */
     functional?: boolean;
+
+    /**
+     * Whether to check undefined value or not.
+     *
+     * JavaScript can assign `undefined` value to a specific property and it is an
+     * issue when validating without allowing superfluous properties. Should undefined
+     * value assigned superfluous property be allowed or not?
+     *
+     * @default true
+     */
+    undefined?: boolean;
 }