typia 3.8.8 → 3.9.0-dev.20230603

package/src/programmers/internal/check_union_array_like.ts

@@ -5,6 +5,8 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { MetadataArray } from "../../metadata/MetadataArray";
+import { MetadataTuple } from "../../metadata/MetadataTuple";
 
 import { CheckerProgrammer } from "../CheckerProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
@@ -14,228 +16,275 @@ import { UnionExplorer } from "../helpers/UnionExplorer";
  * @internal
  */
 export const check_union_array_like =
-    <T>(accessor: check_union_array_like.IAccessor<T>) =>
-    (props: check_union_array_like.IProps<T>) =>
+    <Origin, Category extends MetadataArray | MetadataTuple, Element>(
+        accessor: check_union_array_like.IAccessor<Origin, Category, Element>,
+    ) =>
+    (props: check_union_array_like.IProps<Category, Element>) =>
+    (parameters: ts.ParameterDeclaration[]) =>
     (
         input: ts.Expression,
-        targets: T[],
+        origins: Origin[],
         explore: FeatureProgrammer.IExplore,
         tags: IMetadataTag[],
         jsDocTags: ts.JSDocTagInfo[],
-    ) => {
+    ): ts.ArrowFunction => {
         // ONLY ONE TYPE
+        const targets: Array<Category> = origins.map(accessor.transform);
         if (targets.length === 1)
-            return props.decoder(
-                accessor.array(input),
-                targets[0]!,
-                explore,
-                tags,
-                jsDocTags,
-            );
-
-        //----
-        // 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(
-                                        "top",
-                                        TypeFactory.keyword("any"),
-                                    ),
-                                ],
-                                undefined,
-                                undefined,
-                                props.checker(
-                                    ts.factory.createIdentifier("top"),
-                                    meta,
-                                    {
-                                        ...explore,
-                                        tracable: false,
-                                        postfix: `"[0]"`,
-                                    },
-                                    tags,
-                                    jsDocTags,
-                                    input,
-                                ),
-                            ),
-                            ts.factory.createArrowFunction(
-                                undefined,
-                                undefined,
-                                [
-                                    IdentifierFactory.parameter(
-                                        "top",
-                                        TypeFactory.keyword("any"),
-                                    ),
-                                ],
-                                undefined,
-                                undefined,
-                                props.decoder(
-                                    ts.factory.createIdentifier("top"),
-                                    meta,
-                                    {
-                                        ...explore,
-                                        tracable: true,
-                                    },
-                                    tags,
-                                    jsDocTags,
-                                ),
-                            ),
-                        ]),
-                    ),
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                parameters,
+                undefined,
+                undefined,
+                props.decoder(
+                    accessor.array(input),
+                    targets[0]!,
+                    explore,
+                    tags,
+                    jsDocTags,
                 ),
             );
 
-        // FILTERED TUPLES
-        const filteredVariable = StatementFactory.constant(
-            "filtered",
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("tupleList.filter"),
-                undefined,
+        const array = ts.factory.createIdentifier("array");
+        const top = ts.factory.createIdentifier("top");
+
+        const statements: ts.Statement[] = [];
+        const tupleList: MetadataTuple[] = targets.filter(
+            (t) => t instanceof MetadataTuple,
+        ) as MetadataTuple[];
+        const arrayList: MetadataArray[] = targets.filter(
+            (t) => t instanceof MetadataArray,
+        ) as MetadataArray[];
+
+        const predicate = (meta: Category): ts.ArrayLiteralExpression =>
+            ts.factory.createArrayLiteralExpression(
                 [
                     ts.factory.createArrowFunction(
                         undefined,
                         undefined,
-                        [IdentifierFactory.parameter("tuple")],
+                        [
+                            IdentifierFactory.parameter(
+                                "top",
+                                meta instanceof MetadataArray
+                                    ? TypeFactory.keyword("any")
+                                    : ts.factory.createTypeReferenceNode(
+                                          "any[]",
+                                      ),
+                            ),
+                        ],
+                        TypeFactory.keyword("any"),
                         undefined,
+                        props.checker(
+                            ts.factory.createIdentifier("top"),
+                            accessor.element(meta),
+                            {
+                                ...explore,
+                                tracable: false,
+                                postfix:
+                                    meta instanceof MetadataArray
+                                        ? `"[0]"`
+                                        : "",
+                            },
+                            tags,
+                            jsDocTags,
+                            array,
+                        ),
+                    ),
+                    ts.factory.createArrowFunction(
                         undefined,
-                        ts.factory.createStrictEquality(
-                            props.success,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("tuple[0]"),
-                                undefined,
-                                [ts.factory.createIdentifier("front")],
+                        undefined,
+                        [
+                            IdentifierFactory.parameter(
+                                "entire",
+                                ts.factory.createTypeReferenceNode("any[]"),
                             ),
+                        ],
+                        TypeFactory.keyword("any"),
+                        undefined,
+                        props.decoder(
+                            ts.factory.createIdentifier("entire"),
+                            meta,
+                            {
+                                ...explore,
+                                tracable: true,
+                            },
+                            tags,
+                            jsDocTags,
                         ),
                     ),
                 ],
-            ),
-        );
-
-        //----
-        // 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]`),
+                true,
+            );
+        const iterate =
+            (init: string) =>
+            (from: ts.Expression) =>
+            (stmt: ts.Statement): ts.ForOfStatement =>
+                ts.factory.createForOfStatement(
                     undefined,
-                    [accessor.array(input)],
-                ),
-            ),
-        );
+                    ts.factory.createVariableDeclarationList(
+                        [ts.factory.createVariableDeclaration(init)],
+                        ts.NodeFlags.Const,
+                    ),
+                    from,
+                    stmt,
+                );
 
-        // 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.access(
-                        ts.factory.createIdentifier("array"),
-                    )("every"),
-                    undefined,
-                    [
-                        ts.factory.createArrowFunction(
-                            undefined,
+        if (tupleList.length)
+            statements.push(
+                StatementFactory.constant("array", accessor.array(input)),
+                StatementFactory.constant(
+                    "tuplePredicators",
+                    ts.factory.createArrayLiteralExpression(
+                        tupleList.map((x) => predicate(x as Category)),
+                        true,
+                    ),
+                ),
+                iterate("pred")(
+                    ts.factory.createIdentifier("tuplePredicators"),
+                )(
+                    ts.factory.createIfStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("pred[0]"),
                             undefined,
-                            [
-                                IdentifierFactory.parameter(
-                                    "value",
-                                    TypeFactory.keyword("any"),
+                            [array],
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier(`pred[1]`),
+                                undefined,
+                                [array],
+                            ),
+                        ),
+                    ),
+                ),
+            );
+        if (arrayList.length) {
+            if (tupleList.length === 0)
+                statements.push(
+                    StatementFactory.constant("array", accessor.array(input)),
+                );
+            statements.push(
+                StatementFactory.constant("top", accessor.front(input)),
+                ts.factory.createIfStatement(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(0),
+                        accessor.size(input),
+                    ),
+                    ts.isReturnStatement(props.empty)
+                        ? props.empty
+                        : ts.factory.createReturnStatement(props.empty),
+                ),
+                StatementFactory.constant(
+                    "arrayPredicators",
+                    ts.factory.createArrayLiteralExpression(
+                        arrayList.map((x) => predicate(x as Category)),
+                        true,
+                    ),
+                ),
+                StatementFactory.constant(
+                    "passed",
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                            ts.factory.createIdentifier("arrayPredicators"),
+                        )("filter"),
+                        undefined,
+                        [
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [IdentifierFactory.parameter("pred")],
+                                undefined,
+                                undefined,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("pred[0]"),
+                                    undefined,
+                                    [top],
                                 ),
-                            ],
-                            undefined,
+                            ),
+                        ],
+                    ),
+                ),
+                ts.factory.createIfStatement(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(1),
+                        ts.factory.createIdentifier("passed.length"),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier(`passed[0][1]`),
                             undefined,
-                            ts.factory.createStrictEquality(
-                                props.success,
+                            [array],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createLessThan(
+                            ts.factory.createNumericLiteral(1),
+                            ts.factory.createIdentifier("passed.length"),
+                        ),
+                        iterate("pred")(ts.factory.createIdentifier("passed"))(
+                            ts.factory.createIfStatement(
                                 ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("tuple[0]"),
+                                    IdentifierFactory.access(array)("every"),
                                     undefined,
-                                    [ts.factory.createIdentifier("value")],
+                                    [
+                                        ts.factory.createArrowFunction(
+                                            undefined,
+                                            undefined,
+                                            [
+                                                IdentifierFactory.parameter(
+                                                    "value",
+                                                    TypeFactory.keyword("any"),
+                                                ),
+                                            ],
+                                            undefined,
+                                            undefined,
+                                            ts.factory.createStrictEquality(
+                                                props.success,
+                                                ts.factory.createCallExpression(
+                                                    ts.factory.createIdentifier(
+                                                        "pred[0]",
+                                                    ),
+                                                    undefined,
+                                                    [
+                                                        ts.factory.createIdentifier(
+                                                            "value",
+                                                        ),
+                                                    ],
+                                                ),
+                                            ),
+                                        ),
+                                    ],
+                                ),
+                                ts.factory.createReturnStatement(
+                                    ts.factory.createCallExpression(
+                                        ts.factory.createIdentifier(`pred[1]`),
+                                        undefined,
+                                        [ts.factory.createIdentifier("array")],
+                                    ),
                                 ),
                             ),
                         ),
-                    ],
-                ),
-                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
-            ...(accessor.size !== null
-                ? [
-                      ts.factory.createIfStatement(
-                          ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(0),
-                              accessor.size(input),
-                          ),
-                          ts.isReturnStatement(props.empty)
-                              ? props.empty
-                              : 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,
+            );
+        }
+        statements.push(
             props.failure(
                 input,
-                `(${targets.map((t) => accessor.name(t)).join(" | ")})`,
+                `(${targets
+                    .map((t) => accessor.name(t, accessor.element(t)))
+                    .join(" | ")})`,
                 explore,
             ),
-        ];
-
-        return ts.factory.createCallExpression(
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [],
-                undefined,
-                undefined,
-                ts.factory.createBlock(block, true),
-            ),
+        );
+        return ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            parameters,
             undefined,
             undefined,
+            ts.factory.createBlock(statements, true),
         );
     };
 
@@ -243,16 +292,19 @@ export const check_union_array_like =
  * @internal
  */
 export namespace check_union_array_like {
-    export interface IProps<T> {
+    export interface IProps<
+        Category extends MetadataArray | MetadataTuple,
+        Element,
+    > {
         checker(
             front: ts.Expression,
-            target: T,
+            target: Element,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
             jsDocTags: ts.JSDocTagInfo[],
-            array: ts.Expression,
+            container: ts.Expression,
         ): ts.Expression;
-        decoder: UnionExplorer.Decoder<T>;
+        decoder: UnionExplorer.Decoder<Category>;
         empty: ts.ReturnStatement | ts.Expression;
         success: ts.Expression;
         failure(
@@ -262,10 +314,16 @@ export namespace check_union_array_like {
         ): ts.Statement;
     }
 
-    export interface IAccessor<T> {
-        name(target: T): string;
+    export interface IAccessor<
+        Origin,
+        Category extends MetadataArray | MetadataTuple,
+        Element,
+    > {
+        transform(origin: Origin): Category;
+        element(meta: Category): Element;
+        name(meta: Category, elem: Element): string;
         front(input: ts.Expression): ts.Expression;
         array(input: ts.Expression): ts.Expression;
-        size: null | ((input: ts.Expression) => ts.Expression);
+        size(input: ts.Expression): ts.Expression;
     }
 }

package/src/programmers/internal/feature_object_entries.ts

@@ -41,12 +41,12 @@ export const feature_object_entries =
                 input: propInput,
                 key: prop.key,
                 meta: prop.value,
-                expression: config.decoder(
+                expression: config.decoder()(
                     propInput,
                     prop.value,
                     {
                         tracable: config.path || config.trace,
-                        source: "object",
+                        source: "function",
                         from: "object",
                         postfix:
                             sole !== null

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -0,0 +1,16 @@
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataArray } from "../../metadata/MetadataArray";
+
+export const wrap_metadata_rest_tuple = (rest: Metadata) => {
+    const wrapper: Metadata = Metadata.initialize();
+    wrapper.arrays.push(
+        MetadataArray.create({
+            name: `...${rest.getName()}`,
+            value: rest,
+            nullables: [],
+            recursive: false,
+            index: null,
+        }),
+    );
+    return wrapper;
+};

package/src/schemas/IJsonApplication.ts

@@ -5,9 +5,4 @@ export interface IJsonApplication {
     schemas: IJsonSchema[];
     components: IJsonComponents;
     purpose: "swagger" | "ajv";
-
-    /**
-     * @deprecated Always "#/components/schemas"
-     */
-    prefix: string;
 }

package/src/schemas/IJsonComponents.ts

@@ -3,16 +3,23 @@ import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
 import { IJsonSchema } from "./IJsonSchema";
 
 export interface IJsonComponents {
-    schemas: Record<string, IJsonComponents.IObject>;
+    objects?: Record<string, IJsonComponents.IObject>;
+    definitions?: Record<string, IJsonComponents.IDefinition>;
+    arrays?: Record<string, IJsonComponents.IArray>;
+    tuples?: Record<string, IJsonComponents.ITuple | IJsonComponents.IArray>;
 }
 export namespace IJsonComponents {
+    export interface IArray extends IJsonSchema.IArray {
+        $id?: string;
+        $recursiveAnchor?: true;
+    }
+    export interface ITuple extends IJsonSchema.ITuple {
+        $id?: string;
+        $recursiveAnchor?: true;
+    }
     export interface IObject {
-        /**
-         * Used only when ajv mode.
-         */
         $id?: string;
         $recursiveAnchor?: boolean;
-
         type: "object";
 
         /**
@@ -30,4 +37,9 @@ export namespace IJsonComponents {
         "x-typia-patternProperties"?: Record<string, IJsonSchema>;
         "x-typia-additionalProperties"?: IJsonSchema;
     }
+
+    export type IDefinition = IJsonSchema & {
+        $id?: string;
+        $recursiveAnchor?: boolean;
+    };
 }

package/src/schemas/IJsonSchema.ts

@@ -95,6 +95,7 @@ export namespace IJsonSchema {
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];
+        "x-typia-rest": boolean;
     }
     export interface IReference extends IAttribute {
         $ref: string;
@@ -129,6 +130,5 @@ export namespace IJsonSchema {
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
         "x-typia-optional"?: boolean;
-        "x-typia-rest"?: boolean;
     }
 }

package/src/transformers/CallExpressionTransformer.ts

@@ -78,6 +78,8 @@ export namespace CallExpressionTransformer {
             const functor: (() => Task) | undefined = FUNCTORS[name];
             if (functor === undefined) return expression;
 
+            // console.log(expression.getSourceFile().fileName);
+
             // RETURNS WITH TRANSFORMATION
             return functor()(project)(expression.expression)(expression);
         };

package/src/transformers/FileTransformer.ts

@@ -7,14 +7,14 @@ export namespace FileTransformer {
     export const transform =
         (project: IProject) =>
         (context: ts.TransformationContext) =>
-        (file: ts.SourceFile): ts.SourceFile =>
-            file.isDeclarationFile
-                ? file
-                : ts.visitEachChild(
-                      file,
-                      (node) => iterate_node(project)(context)(node),
-                      context,
-                  );
+        (file: ts.SourceFile): ts.SourceFile => {
+            if (file.isDeclarationFile) return file;
+            return ts.visitEachChild(
+                file,
+                (node) => iterate_node(project)(context)(node),
+                context,
+            );
+        };
 
     const iterate_node =
         (project: IProject) =>

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -54,6 +54,7 @@ export namespace ApplicationTransformer {
                 MetadataFactory.analyze(checker)({
                     resolve: true,
                     constant: true,
+                    absorb: false,
                     validate: (meta) => {
                         if (meta.atomics.find((str) => str === "bigint"))
                             throw new Error(NO_BIGIT);

package/src/transformers/features/miscellaneous/MetadataTransformer.ts

@@ -35,13 +35,14 @@ export namespace MetadataTransformer {
                 MetadataFactory.analyze(checker)({
                     resolve: false,
                     constant: true,
+                    absorb: true,
                 })(collection)(type),
             );
 
             // CONVERT TO PRIMITIVE TYPE
             const app: IMetadataApplication = {
                 metadatas: metadatas.map((metadata) => metadata.toJSON()),
-                collection: collection.objects().map((obj) => obj.toJSON()),
+                collection: collection.toJSON(),
             };
             return LiteralFactory.generate(app);
         };