typia 3.5.0-dev.20221219 → 3.5.0-dev.20230107

package/src/programmers/StringifyProgrammer.ts

@@ -498,7 +498,7 @@ export namespace StringifyProgrammer {
                     );
             else if (
                 type === "number" &&
-                OptionPredicator.numeric(project.options, "stringify")
+                OptionPredicator.numeric(project.options)
             )
                 input = ts.factory.createCallExpression(
                     importer.use("number"),
@@ -700,6 +700,10 @@ export namespace StringifyProgrammer {
             {
                 resolve: true,
                 constant: true,
+                validate: (meta) => {
+                    if (meta.atomics.find((str) => str === "bigint"))
+                        throw new Error(NO_BIGINT);
+                },
             },
         );
         return [collection, meta];
@@ -754,3 +758,5 @@ interface IUnion {
     is: () => ts.Expression;
     value: () => ts.Expression;
 }
+
+const NO_BIGINT = "Error on typia.stringify(): does not allow bigint type.";

package/src/programmers/ValidateParseProgrammer.ts

@@ -20,7 +20,17 @@ export namespace ValidateParseProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "validate",
-                        ValidateProgrammer.generate(project, modulo)(type),
+                        ValidateProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/ValidateProgrammer.ts

@@ -8,6 +8,7 @@ import { IProject } from "../transformers/IProject";
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
 
@@ -27,7 +28,7 @@ export namespace ValidateProgrammer {
                     unioners: "$vu",
                     path: true,
                     trace: true,
-                    numeric: !!project.options.numeric,
+                    numeric: OptionPredicator.numeric(project.options),
                     equals,
                     combiner: combine(equals)(importer),
                     joiner: joiner(equals)(importer),
@@ -87,7 +88,7 @@ const combine =
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
-        if (explore.tracable === false && explore.from !== "top")
+        if (explore.tracable === false)
             return IsProgrammer.CONFIG({
                 object: validate_object(equals)(importer),
                 numeric: true,

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -21,11 +21,31 @@ export namespace ValidateStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "validate",
-                        ValidateProgrammer.generate(project, modulo)(type),
+                        ValidateProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     StatementFactory.constant(
                         "stringify",
-                        StringifyProgrammer.generate(project, modulo)(type),
+                        StringifyProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     StatementFactory.constant(
                         "output",

package/src/programmers/helpers/OptionPredicator.ts

@@ -1,18 +1,15 @@
 import { ITransformOptions } from "../../transformers/ITransformOptions";
 
 export namespace OptionPredicator {
+    export function numeric(options: ITransformOptions): boolean {
+        return finite(options) || options.numeric === true;
+    }
+
     export function functional(options: ITransformOptions): boolean {
-        return options.functional !== false;
+        return options.functional === true;
     }
 
-    export function numeric(
-        options: ITransformOptions,
-        from: "checker" | "stringify",
-    ): boolean {
-        return (
-            options.numeric === undefined ||
-            options.numeric === true ||
-            options.numeric === from
-        );
+    export function finite(options: ITransformOptions): boolean {
+        return options.finite === true;
     }
 }

package/src/programmers/helpers/UnionExplorer.ts

@@ -2,14 +2,13 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
 import { MetadataObject } from "../../metadata/MetadataObject";
 
-import { CheckerProgrammer } from "../CheckerProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
+import { check_union_array_like } from "../internal/check_union_array_like";
 import { UnionPredicator } from "./UnionPredicator";
 
 export namespace UnionExplorer {
@@ -23,16 +22,17 @@ export namespace UnionExplorer {
     }
     export type ObjectCombiner = Decoder<MetadataObject[]>;
 
-    export function object(
-        config: FeatureProgrammer.IConfig,
-        level: number = 0,
-    ) {
-        return function (
+    /* -----------------------------------------------------------
+        OBJECT
+    ----------------------------------------------------------- */
+    export const object =
+        (config: FeatureProgrammer.IConfig, level: number = 0) =>
+        (
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-        ): ts.Expression {
+        ): ts.Expression => {
             // BREAKER
             if (targets.length === 1)
                 return config.objector.decoder(
@@ -135,10 +135,25 @@ export namespace UnionExplorer {
                 undefined,
             );
         };
+
+    /* -----------------------------------------------------------
+        ARRAY LIKE
+    ----------------------------------------------------------- */
+    export const tuple = (props: check_union_array_like.IProps<Metadata[]>) =>
+        check_union_array_like<Metadata[]>({
+            size: null,
+            front: (input) => input,
+            array: (input) => input,
+            name: (elems) => `[${elems.map((e) => e.getName()).join(", ")}]`,
+        })(props);
+    export namespace tuple {
+        export type IProps = check_union_array_like.IProps<
+            Metadata | Metadata[]
+        >;
     }
 
     export const array = (props: array.IProps) =>
-        iterate<Metadata>({
+        check_union_array_like<Metadata>({
             size: (input) => IdentifierFactory.join(input, "length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
@@ -146,11 +161,28 @@ export namespace UnionExplorer {
             name: (t) => `Array<${t.getName()}>`,
         })(props);
     export namespace array {
-        export type IProps = iterate.IProps<Metadata>;
+        export type IProps = check_union_array_like.IProps<Metadata>;
+    }
+
+    export const array_or_tuple = (props: array_or_tuple.IProps) =>
+        check_union_array_like<Metadata | Metadata[]>({
+            size: (input) => IdentifierFactory.join(input, "length"),
+            front: (input) =>
+                ts.factory.createElementAccessExpression(input, 0),
+            array: (input) => input,
+            name: (t) =>
+                Array.isArray(t)
+                    ? `[${t.map((e) => e.getName()).join(", ")}]`
+                    : `Array<${t.getName()}>`,
+        })(props);
+    export namespace array_or_tuple {
+        export type IProps = check_union_array_like.IProps<
+            Metadata | Metadata[]
+        >;
     }
 
     export const set = (props: set.IProps) =>
-        iterate<Metadata>({
+        check_union_array_like<Metadata>({
             size: (input) => IdentifierFactory.join(input, "size"),
             front: (input) =>
                 IdentifierFactory.join(
@@ -176,11 +208,11 @@ export namespace UnionExplorer {
             name: (t) => `Set<${t.getName()}>`,
         })(props);
     export namespace set {
-        export type IProps = iterate.IProps<Metadata>;
+        export type IProps = check_union_array_like.IProps<Metadata>;
     }
 
     export const map = (props: map.IProps) =>
-        iterate<[Metadata, Metadata]>({
+        check_union_array_like<[Metadata, Metadata]>({
             size: (input) => IdentifierFactory.join(input, "size"),
             front: (input) =>
                 IdentifierFactory.join(
@@ -207,231 +239,36 @@ export namespace UnionExplorer {
         })(props);
 
     export namespace map {
-        export type IProps = iterate.IProps<[Metadata, Metadata]>;
+        export type IProps = check_union_array_like.IProps<
+            [Metadata, Metadata]
+        >;
     }
 
-    const iterate =
-        <T>(accessor: iterate.IAccessor<T>) =>
-        (props: iterate.IProps<T>) =>
-        (
-            input: ts.Expression,
-            targets: T[],
-            explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-        ): ts.Expression => {
-            if (targets.length === 1)
-                return props.decoder(
-                    accessor.array(input),
-                    targets[0]!,
-                    explore,
-                    tags,
-                );
-
-            //----
-            // LIST UP VARIABLES
-            //----
-            // TUPLES
-            const tupleListVariable: ts.VariableStatement =
-                StatementFactory.constant(
-                    "tupleList",
-                    ts.factory.createArrayLiteralExpression(
-                        targets.map((meta) =>
-                            ts.factory.createArrayLiteralExpression([
-                                ts.factory.createArrowFunction(
-                                    undefined,
-                                    undefined,
-                                    [IdentifierFactory.parameter("branch")],
-                                    undefined,
-                                    undefined,
-                                    props.checker(
-                                        ts.factory.createIdentifier("branch"),
-                                        meta,
-                                        {
-                                            ...explore,
-                                            tracable: false,
-                                            postfix: `"[0]"`,
-                                        },
-                                        tags,
-                                    ),
-                                ),
-                                ts.factory.createArrowFunction(
-                                    undefined,
-                                    undefined,
-                                    [IdentifierFactory.parameter("branch")],
-                                    undefined,
-                                    undefined,
-                                    props.decoder(
-                                        ts.factory.createIdentifier("branch"),
-                                        meta,
-                                        {
-                                            ...explore,
-                                            tracable: true,
-                                        },
-                                        tags,
-                                    ),
-                                ),
-                            ]),
-                        ),
-                    ),
-                );
-
-            // FILTERED TUPLES
-            const filteredVariable = StatementFactory.constant(
-                "filtered",
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("tupleList.filter"),
-                    undefined,
-                    [
-                        ts.factory.createArrowFunction(
-                            undefined,
-                            undefined,
-                            [IdentifierFactory.parameter("tuple")],
-                            undefined,
-                            undefined,
-                            ts.factory.createStrictEquality(
-                                props.success,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("tuple[0]"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("front")],
-                                ),
-                            ),
-                        ),
-                    ],
-                ),
-            );
-
-            //----
-            // STATEMENTS
-            //----
-            // ONLY ONE TYPE
-            const uniqueStatement = ts.factory.createIfStatement(
-                ts.factory.createStrictEquality(
-                    ts.factory.createNumericLiteral(1),
-                    ts.factory.createIdentifier("filtered.length"),
-                ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(`filtered[0][1]`),
-                        undefined,
-                        [accessor.array(input)],
-                    ),
-                ),
-            );
-
-            // UNION TYPE
-            const forOfStatement = ts.factory.createForOfStatement(
-                undefined,
-                ts.factory.createVariableDeclarationList(
-                    [ts.factory.createVariableDeclaration("tuple")],
-                    ts.NodeFlags.Const,
-                ),
-                // StatementFactory.variable(ts.NodeFlags.Const, "tuple"),
-                ts.factory.createIdentifier("filtered"),
-                ts.factory.createIfStatement(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.join(
-                            ts.factory.createIdentifier("array"),
-                            "every",
-                        ),
-                        undefined,
-                        [
-                            ts.factory.createArrowFunction(
-                                undefined,
-                                undefined,
-                                [IdentifierFactory.parameter("value")],
-                                undefined,
-                                undefined,
-                                ts.factory.createStrictEquality(
-                                    props.success,
-                                    ts.factory.createCallExpression(
-                                        ts.factory.createIdentifier("tuple[0]"),
-                                        undefined,
-                                        [ts.factory.createIdentifier("value")],
-                                    ),
-                                ),
-                            ),
-                        ],
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier(`tuple[1]`),
-                            undefined,
-                            [ts.factory.createIdentifier("array")],
-                        ),
-                    ),
-                ),
-            );
-            const unionStatement = ts.factory.createIfStatement(
-                ts.factory.createLessThan(
-                    ts.factory.createNumericLiteral(1),
-                    ts.factory.createIdentifier("filtered.length"),
-                ),
-                forOfStatement,
-            );
-
-            const block = [
-                // ARRAY.LENGTH := 0
-                ts.factory.createIfStatement(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        accessor.size(input),
-                    ),
-                    ts.factory.createReturnStatement(props.empty),
-                ),
-
-                // UNION PREDICATORS
-                tupleListVariable,
-                StatementFactory.constant("front", accessor.front(input)),
-                filteredVariable,
-                uniqueStatement,
-
-                // CONDITIONAL STATEMENTS
-                StatementFactory.constant("array", accessor.array(input)),
-                unionStatement,
-                props.failure(
-                    input,
-                    `(${targets.map((t) => accessor.name(t)).join(" | ")})`,
-                    explore,
-                ),
-            ];
-
-            return ts.factory.createCallExpression(
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(block, true),
-                ),
-                undefined,
-                undefined,
-            );
-        };
-    namespace iterate {
-        export interface IProps<T> {
-            checker(
-                input: ts.Expression,
-                target: T,
-                explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
-            ): ts.Expression;
-            decoder: Decoder<T>;
-            empty: ts.Expression;
-            success: ts.Expression;
-            failure(
-                input: ts.Expression,
-                expected: string,
-                explore: CheckerProgrammer.IExplore,
-            ): ts.Statement;
-        }
-
-        export interface IAccessor<T> {
-            name(metadata: T): string;
-            size(input: ts.Expression): ts.Expression;
-            front(input: ts.Expression): ts.Expression;
-            array(input: ts.Expression): ts.Expression;
-        }
-    }
+    // const transform = <T>(
+    //     props: check_union_array_like.IProps<T>,
+    // ): check_union_array_like.IProps<T> => ({
+    //     ...props,
+    //     checker: (top, targets, explore, tags, array) =>
+    //         props.checker(
+    //             top,
+    //             targets,
+    //             {
+    //                 ...explore,
+    //                 tracable: false,
+    //                 postfix: `"[0]"`,
+    //             },
+    //             tags,
+    //             array,
+    //         ),
+    //     decoder: (input, targets, explore, tags) =>
+    //         props.decoder(
+    //             input,
+    //             targets,
+    //             {
+    //                 ...explore,
+    //                 tracable: true,
+    //             },
+    //             tags,
+    //         ),
+    // });
 }

package/src/programmers/internal/application_default.ts

@@ -1,4 +1,4 @@
-import { IJsonSchema } from "../../module";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
 
 /**
  * @internal

package/src/programmers/internal/application_object.ts

@@ -17,10 +17,10 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (key: string, obj: MetadataObject, nullable: boolean): void => {
+    (id: string, obj: MetadataObject, nullable: boolean): void => {
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[key] !== undefined) return;
-        components.schemas[key] = {} as any;
+        if (components.schemas[id] !== undefined) return;
+        components.schemas[id] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -80,7 +80,7 @@ export const application_object =
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
-                    ? options.prefix + "/" + key
+                    ? options.prefix + "/" + id
                     : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
@@ -99,5 +99,5 @@ export const application_object =
             description: obj.description,
             "x-typia_jsDocTags": obj.jsDocTags,
         };
-        components.schemas[key] = schema;
+        components.schemas[id] = schema;
     };

package/src/programmers/internal/application_schema.ts

@@ -4,6 +4,7 @@ import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
 
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
@@ -50,13 +51,18 @@ export const application_schema =
         if (meta.templates.length && AtomicPredicator.template(meta))
             union.push(application_templates(meta, attribute));
         for (const constant of meta.constants) {
-            if (constant.type === "string" && meta.templates.length) continue;
-            else if (!AtomicPredicator.constant(meta)(constant.type)) continue;
+            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) {
+            if (type === "bigint") throw new Error(NO_BIGINT);
             union.push(
                 type === "string"
                     ? application_string(meta, attribute)
@@ -90,6 +96,11 @@ export const application_schema =
                     ),
                 );
             else {
+                if (items.length === 0)
+                    throw new Error(
+                        "Error on typia.application(): swagger does not support zero length tuple type.",
+                    );
+
                 // SWAGGER DOES NOT SUPPORT TUPLE TYPE YET
                 const merged: Metadata = items.reduce((x, y) =>
                     merge_metadata(x, y),
@@ -128,12 +139,14 @@ export const application_schema =
 
         // OBJECT
         for (const obj of meta.objects) {
-            const key: string = obj.name + (meta.nullable ? ".Nullable" : "");
-            application_object(options)(components)(key, obj, meta.nullable);
+            const id: string =
+                NameEncoder.encode(obj.name) +
+                (meta.nullable ? ".Nullable" : "");
+            application_object(options)(components)(id, obj, meta.nullable);
             union.push(
                 (options.purpose === "ajv" && obj.recursive
                     ? recursive
-                    : reference)(`${options.prefix}/${key}`, attribute),
+                    : reference)(`${options.prefix}/${id}`, attribute),
             );
         }
 
@@ -219,3 +232,5 @@ function merge_metadata(x: Metadata, y: Metadata): Metadata {
 
     return output;
 }
+
+const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/check_array.ts

@@ -1,11 +1,10 @@
 import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
-import { check_length } from "./check_length";
+import { check_array_length } from "./check_array_length";
 
 /**
  * @internal
@@ -16,29 +15,8 @@ export function check_array(
 ): ts.Expression {
     const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
 
-    // CHECK TAGS
-    for (const tag of tagList)
-        if (tag.kind === "minItems")
-            conditions.push(
-                ts.factory.createLessThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "maxItems")
-            conditions.push(
-                ts.factory.createGreaterThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "items")
-            check_length(
-                conditions,
-                IdentifierFactory.join(input, "length"),
-                tag,
-            );
+    const length: ts.Expression | null = check_array_length(input, tagList);
+    if (length !== null) conditions.push(length);
 
-    // COMBINATION
     return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
 }