typia 3.5.0-dev.20230125 → 3.5.0-dev.20230211

package/src/programmers/StringifyProgrammer.ts

@@ -12,6 +12,8 @@ import { MetadataObject } from "../metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
 
+import { Atomic } from "../typings/Atomic";
+
 import { ArrayUtil } from "../utils/ArrayUtil";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
@@ -23,6 +25,7 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { StringifyJoiner } from "./helpers/StringifyJoinder";
 import { StringifyPredicator } from "./helpers/StringifyPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
+import { check_native } from "./internal/check_native";
 import { decode_union_object } from "./internal/decode_union_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
@@ -177,10 +180,9 @@ export namespace StringifyProgrammer {
 
             // CONSTANTS
             for (const constant of meta.constants)
-                if (
-                    constant.type !== "string" &&
-                    AtomicPredicator.constant(meta)(constant.type)
-                )
+                if (AtomicPredicator.constant(meta)(constant.type) === false)
+                    continue;
+                else if (constant.type !== "string")
                     unions.push({
                         type: "atomic",
                         is: () =>
@@ -223,28 +225,31 @@ export namespace StringifyProgrammer {
                                 explore,
                             ),
                     });
+
+            /// ATOMICS
             for (const type of meta.atomics)
-                unions.push({
-                    type: "atomic",
-                    is: () =>
-                        IsProgrammer.decode(project, importer)(
-                            input,
-                            (() => {
-                                const partial = Metadata.initialize();
-                                partial.atomics.push(type);
-                                return partial;
-                            })(),
-                            explore,
-                            [],
-                        ),
-                    value: () =>
-                        decode_atomic(project, importer)(
-                            input,
-                            type,
-                            explore,
-                            tags,
-                        ),
-                });
+                if (AtomicPredicator.atomic(meta)(type))
+                    unions.push({
+                        type: "atomic",
+                        is: () =>
+                            IsProgrammer.decode(project, importer)(
+                                input,
+                                (() => {
+                                    const partial = Metadata.initialize();
+                                    partial.atomics.push(type);
+                                    return partial;
+                                })(),
+                                explore,
+                                [],
+                            ),
+                        value: () =>
+                            decode_atomic(project, importer)(
+                                input,
+                                type,
+                                explore,
+                                tags,
+                            ),
+                    });
 
             // TUPLES
             for (const tuple of meta.tuples) {
@@ -315,8 +320,16 @@ export namespace StringifyProgrammer {
                 for (const native of meta.natives)
                     unions.push({
                         type: "object",
-                        is: () => ExpressionFactory.isInstanceOf(input, native),
-                        value: () => ts.factory.createStringLiteral("{}"),
+                        is: () => check_native(native)(input),
+                        value: () =>
+                            AtomicPredicator.native(native)
+                                ? decode_atomic(project, importer)(
+                                      input,
+                                      native.toLowerCase() as Atomic.Literal,
+                                      explore,
+                                      tags,
+                                  )
+                                : ts.factory.createStringLiteral("{}"),
                     });
 
             // SETS
@@ -356,13 +369,16 @@ export namespace StringifyProgrammer {
                         meta.objects[0]!._Is_simple()
                             ? (() => {
                                   const obj: MetadataObject = meta.objects[0]!;
-                                  const entries: IExpressionEntry[] =
-                                      feature_object_entries({
+                                  const entries: IExpressionEntry<ts.Expression>[] =
+                                      feature_object_entries<ts.Expression>({
                                           decoder: decode(project, importer),
                                           trace: false,
                                           path: false,
-                                      })(obj)(input);
+                                      })(obj)(
+                                          input,
+                                      );
                                   return StringifyJoiner.object(importer)(
+                                      input,
                                       entries,
                                   );
                               })()
@@ -691,7 +707,10 @@ export namespace StringifyProgrammer {
         objector: OBJECTOR(project, importer),
     });
 
-    const initializer: FeatureProgrammer.Initializer = ({ checker }, type) => {
+    const initializer: FeatureProgrammer.IConfig["initializer"] = (
+        { checker },
+        type,
+    ) => {
         const collection: MetadataCollection = new MetadataCollection();
         const meta: Metadata = MetadataFactory.generate(
             checker,
@@ -716,15 +735,13 @@ 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),
         ),
         failure: (input, expected) =>
             create_throw_error(importer, input, expected),
-        is: (expr) => expr,
-        required: (expr) => expr,
     });
 
     function create_throw_error(

package/src/programmers/ValidateProgrammer.ts

@@ -92,7 +92,7 @@ const combine =
             return IsProgrammer.CONFIG({
                 object: validate_object(equals)(importer),
                 numeric: true,
-            }).combiner(explore);
+            })(importer).combiner(explore);
 
         const path: string = explore.postfix
             ? `path + ${explore.postfix}`
@@ -134,6 +134,7 @@ const combine =
 const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
     check_object({
         equals,
+        undefined: true,
         assert: false,
         reduce: ts.factory.createLogicalAnd,
         positive: ts.factory.createTrue(),
@@ -158,7 +159,7 @@ const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
                 ),
                 expr,
             ),
-    });
+    })(importer);
 
 const joiner =
     (equals: boolean) =>

package/src/programmers/helpers/AtomicPredicator.ts

@@ -8,8 +8,24 @@ export namespace AtomicPredicator {
     export const constant =
         (meta: Metadata) =>
         (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name);
+            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
 
     export const template = (meta: Metadata): boolean =>
         !ArrayUtil.has(meta.atomics, (type) => type === "string");
 }
+
+const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/helpers/IExpressionEntry.ts

@@ -2,9 +2,11 @@ import ts from "typescript";
 
 import { Metadata } from "../../metadata/Metadata";
 
-export interface IExpressionEntry {
+export interface IExpressionEntry<
+    Expression extends ts.ConciseBody = ts.ConciseBody,
+> {
     input: ts.Expression;
     key: Metadata;
     meta: Metadata;
-    expression: ts.Expression;
+    expression: Expression;
 }

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/helpers/PruneJoiner.ts

@@ -0,0 +1,52 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+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 => {
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            entries.map((entry) =>
+                ts.isBlock(entry.expression)
+                    ? [...entry.expression.statements]
+                    : [ts.factory.createExpressionStatement(entry.expression)],
+            ),
+        );
+        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.join(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);
+    };
+}

package/src/programmers/helpers/StringifyJoinder.ts

@@ -11,12 +11,15 @@ import { IExpressionEntry } from "./IExpressionEntry";
 export namespace StringifyJoiner {
     export const object =
         (importer: FunctionImporter) =>
-        (entries: IExpressionEntry[]): ts.Expression => {
+        (
+            _input: ts.Expression,
+            entries: IExpressionEntry<ts.Expression>[],
+        ): ts.Expression => {
             // CHECK AND SORT ENTRIES
-            const regular: IExpressionEntry[] = entries.filter((entry) =>
-                entry.key.isSoleLiteral(),
+            const regular: IExpressionEntry<ts.Expression>[] = entries.filter(
+                (entry) => entry.key.isSoleLiteral(),
             );
-            const dynamic: IExpressionEntry[] = entries.filter(
+            const dynamic: IExpressionEntry<ts.Expression>[] = entries.filter(
                 (entry) => !entry.key.isSoleLiteral(),
             );
             if (regular.length === 0 && dynamic.length === 0)

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";
@@ -48,27 +46,28 @@ export const application_schema =
         // ATOMIC TYPES
         if (meta.templates.length && AtomicPredicator.template(meta))
             union.push(application_templates(meta, attribute));
-        for (const constant of meta.constants) {
+        for (const constant of meta.constants)
             if (constant.type === "bigint") throw new Error(NO_BIGINT);
             else if (
                 (constant.type === "string" && meta.templates.length) ||
                 AtomicPredicator.constant(meta)(constant.type) === false
             )
                 continue;
-            union.push(
-                application_constant(constant, meta.nullable, attribute),
-            );
-        }
-        for (const type of meta.atomics) {
+            else
+                union.push(
+                    application_constant(constant, meta.nullable, attribute),
+                );
+        for (const type of meta.atomics)
             if (type === "bigint") throw new Error(NO_BIGINT);
-            union.push(
-                type === "string"
-                    ? application_string(meta, attribute)
-                    : type === "boolean"
-                    ? application_boolean(meta.nullable, attribute)
-                    : application_number(meta.nullable, attribute),
-            );
-        }
+            else if (AtomicPredicator.atomic(meta)(type) === false) continue;
+            else
+                union.push(
+                    type === "string"
+                        ? application_string(meta, attribute)
+                        : type === "boolean"
+                        ? application_boolean(meta.nullable, attribute)
+                        : application_number(meta.nullable, attribute),
+                );
 
         // ARRAY
         for (const schema of meta.arrays.values())
@@ -111,12 +110,21 @@ export const application_schema =
 
         // NATIVES
         for (const native of meta.natives)
-            union.push(
-                application_native(options)(components)(native)(
-                    meta.nullable,
-                    attribute,
-                ),
-            );
+            if (AtomicPredicator.native(native))
+                union.push(
+                    native === "String"
+                        ? application_string(meta, attribute)
+                        : native === "Boolean"
+                        ? application_boolean(meta.nullable, attribute)
+                        : application_number(meta.nullable, attribute),
+                );
+            else
+                union.push(
+                    application_native(options)(components)(native)(
+                        meta.nullable,
+                        attribute,
+                    ),
+                );
         if (meta.sets.length)
             union.push(
                 application_native(options)(components)(`Set`)(
@@ -134,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/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,39 +14,87 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  */
 export const check_dynamic_properties =
     (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
     (
-        regular: IExpressionEntry[],
-        dynamic: IExpressionEntry[],
+        input: ts.Expression,
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
     ): ts.Expression => {
+        const length = IdentifierFactory.join(
+            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,
-                      [ts.factory.createIdentifier("input")],
+                      [input],
                   ),
-                  check_dynamic_property(props)(regular, dynamic),
+                  check_dynamic_property(props)(input, regular, dynamic),
               ])
             : ts.factory.createCallExpression(
                   IdentifierFactory.join(
                       ts.factory.createCallExpression(
                           ts.factory.createIdentifier("Object.keys"),
                           undefined,
-                          [ts.factory.createIdentifier("input")],
+                          [input],
                       ),
                       props.assert ? "every" : "map",
                   ),
                   undefined,
-                  [check_dynamic_property(props)(regular, dynamic)],
+                  [check_dynamic_property(props)(input, regular, dynamic)],
               );
-        return (props.halt || ((elem) => elem))(
+        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) =>
-    (regular: IExpressionEntry[], dynamic: IExpressionEntry[]) => {
+    (
+        input: ts.Expression,
+        regular: IExpressionEntry<ts.Expression>[],
+        dynamic: IExpressionEntry<ts.Expression>[],
+    ) => {
         //----
         // IF CONDITIONS
         //----
@@ -68,16 +117,18 @@ const check_dynamic_property =
         statements.push(
             StatementFactory.constant(
                 "value",
-                ts.factory.createIdentifier("input[key]"),
-            ),
-        );
-        add(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                value,
+                ts.factory.createElementAccessExpression(input, key),
             ),
-            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_native.ts

@@ -5,5 +5,17 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 /**
  * @internal
  */
-export const check_native = (type: string) => (input: ts.Expression) =>
-    ExpressionFactory.isInstanceOf(input, type);
+export const check_native = (type: string) => (input: ts.Expression) => {
+    const instanceOf = ExpressionFactory.isInstanceOf(input, type);
+    return ATOMIC_LIKE.has(type)
+        ? ts.factory.createLogicalOr(
+              ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral(type.toLowerCase()),
+                  ts.factory.createTypeOfExpression(input),
+              ),
+              instanceOf,
+          )
+        : instanceOf;
+};
+
+const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

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) =>
+    (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
         // PREPARE ASSETS
         const regular = entries.filter((entry) => entry.key.isSoleLiteral());
         const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
@@ -19,13 +22,16 @@ 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)(input, 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/programmers/internal/check_union_array_like.ts

@@ -180,7 +180,9 @@ export const check_union_array_like =
                               ts.factory.createNumericLiteral(0),
                               accessor.size(input),
                           ),
-                          ts.factory.createReturnStatement(props.empty),
+                          ts.isReturnStatement(props.empty)
+                              ? props.empty
+                              : ts.factory.createReturnStatement(props.empty),
                       ),
                   ]
                 : []),
@@ -224,7 +226,7 @@ export namespace check_union_array_like {
             array: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<T>;
-        empty: ts.Expression;
+        empty: ts.ReturnStatement | ts.Expression;
         success: ts.Expression;
         failure(
             input: ts.Expression,

package/src/programmers/internal/feature_object_entries.ts

@@ -9,7 +9,12 @@ import { Escaper } from "../../utils/Escaper";
 import { FeatureProgrammer } from "../FeatureProgrammer";
 
 export const feature_object_entries =
-    (config: Pick<FeatureProgrammer.IConfig, "decoder" | "path" | "trace">) =>
+    <Output extends ts.ConciseBody>(
+        config: Pick<
+            FeatureProgrammer.IConfig<Output>,
+            "decoder" | "path" | "trace"
+        >,
+    ) =>
     (obj: MetadataObject) =>
     (input: ts.Expression) =>
         obj.properties.map((prop) => {