typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/helpers/UnionExplorer.ts

@@ -1,12 +1,13 @@
-import { JSDocTagInfo } from "typescript";
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
+import { MetadataArray } from "../../metadata/MetadataArray";
 import { MetadataObject } from "../../metadata/MetadataObject";
+import { MetadataTuple } from "../../metadata/MetadataTuple";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { check_union_array_like } from "../internal/check_union_array_like";
@@ -19,7 +20,7 @@ export namespace UnionExplorer {
             target: T,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-            jsDocTags: JSDocTagInfo[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression;
     }
     export type ObjectCombiner = Decoder<MetadataObject[]>;
@@ -28,18 +29,17 @@ export namespace UnionExplorer {
         OBJECT
     ----------------------------------------------------------- */
     export const object =
-        (tsc: typeof ts) =>
         (config: FeatureProgrammer.IConfig, level: number = 0) =>
         (
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-            jsDocTags: JSDocTagInfo[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             // BREAKER
             if (targets.length === 1)
-                return config.objector.decoder(
+                return config.objector.decoder()(
                     input,
                     targets[0]!,
                     explore,
@@ -78,9 +78,9 @@ export namespace UnionExplorer {
                 .map((spec) => {
                     const key: string = spec.property.key.getSoleLiteral()!;
                     const accessor: ts.Expression =
-                        IdentifierFactory.access(tsc)(input)(key);
+                        IdentifierFactory.access(input)(key);
                     const pred: ts.Expression = spec.neighbour
-                        ? config.objector.checker(
+                        ? config.objector.checker()(
                               accessor,
                               spec.property.value,
                               {
@@ -92,12 +92,12 @@ export namespace UnionExplorer {
                               jsDocTags,
                           )
                         : (config.objector.required || ((exp) => exp))(
-                              ExpressionFactory.isRequired(tsc)(accessor),
+                              ExpressionFactory.isRequired(accessor),
                           );
-                    return tsc.factory.createIfStatement(
+                    return ts.factory.createIfStatement(
                         (config.objector.is || ((exp) => exp))(pred),
-                        tsc.factory.createReturnStatement(
-                            config.objector.decoder(
+                        ts.factory.createReturnStatement(
+                            config.objector.decoder()(
                                 input,
                                 spec.object,
                                 explore,
@@ -109,19 +109,19 @@ export namespace UnionExplorer {
                 });
 
             // RETURNS WITH CONDITIONS
-            return tsc.factory.createCallExpression(
-                tsc.factory.createArrowFunction(
+            return ts.factory.createCallExpression(
+                ts.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [],
                     undefined,
                     undefined,
-                    tsc.factory.createBlock(
+                    ts.factory.createBlock(
                         [
                             ...conditions,
                             remained.length
-                                ? tsc.factory.createReturnStatement(
-                                      object(tsc)(config, level + 1)(
+                                ? ts.factory.createReturnStatement(
+                                      object(config, level + 1)(
                                           input,
                                           remained,
                                           explore,
@@ -146,61 +146,80 @@ export namespace UnionExplorer {
     /* -----------------------------------------------------------
         ARRAY LIKE
     ----------------------------------------------------------- */
-    export const tuple =
-        (tsc: typeof ts) =>
-        (props: check_union_array_like.IProps<Metadata[]>) =>
-            check_union_array_like(tsc)<Metadata[]>({
-                size: null,
-                front: (input) => input,
-                array: (input) => input,
-                name: (elems) =>
-                    `[${elems.map((e) => e.getName()).join(", ")}]`,
-            })(props);
+    export const tuple = (
+        props: check_union_array_like.IProps<MetadataTuple, MetadataTuple>,
+    ) =>
+        check_union_array_like<MetadataTuple, MetadataTuple, MetadataTuple>({
+            transform: (x) => x,
+            element: (x) => x,
+            size: null!,
+            front: (input) => input,
+            array: (input) => input,
+            name: (t) => t.name,
+        })(props);
     export namespace tuple {
         export type IProps = check_union_array_like.IProps<
-            Metadata | Metadata[]
+            MetadataTuple,
+            MetadataTuple
         >;
     }
 
-    export const array = (tsc: typeof ts) => (props: array.IProps) =>
-        check_union_array_like(tsc)<Metadata>({
-            size: (input) => IdentifierFactory.access(tsc)(input)("length"),
+    export const array = (props: array.IProps) =>
+        check_union_array_like<MetadataArray, MetadataArray, Metadata>({
+            transform: (x) => x,
+            element: (x) => x.value,
+            size: (input) => IdentifierFactory.access(input)("length"),
             front: (input) =>
-                tsc.factory.createElementAccessExpression(input, 0),
+                ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
-            name: (t) => `Array<${t.getName()}>`,
+            name: (t) => t.name,
         })(props);
     export namespace array {
-        export type IProps = check_union_array_like.IProps<Metadata>;
+        export type IProps = check_union_array_like.IProps<
+            MetadataArray,
+            Metadata
+        >;
     }
 
-    export const array_or_tuple =
-        (tsc: typeof ts) => (props: array_or_tuple.IProps) =>
-            check_union_array_like(tsc)<Metadata | Metadata[]>({
-                size: (input) => IdentifierFactory.access(tsc)(input)("length"),
-                front: (input) =>
-                    tsc.factory.createElementAccessExpression(input, 0),
-                array: (input) => input,
-                name: (t) =>
-                    Array.isArray(t)
-                        ? `[${t.map((e) => e.getName()).join(", ")}]`
-                        : `Array<${t.getName()}>`,
-            })(props);
+    export const array_or_tuple = (props: array_or_tuple.IProps) =>
+        check_union_array_like<
+            MetadataArray | MetadataTuple,
+            MetadataArray | MetadataTuple,
+            Metadata | MetadataTuple
+        >({
+            transform: (x) => x,
+            element: (x) => (x instanceof MetadataArray ? x.value : x),
+            size: (input) => IdentifierFactory.access(input)("length"),
+            front: (input) =>
+                ts.factory.createElementAccessExpression(input, 0),
+            array: (input) => input,
+            name: (m) => m.name,
+        })(props);
     export namespace array_or_tuple {
         export type IProps = check_union_array_like.IProps<
-            Metadata | Metadata[]
+            MetadataArray | MetadataTuple,
+            Metadata
         >;
     }
 
-    export const set = (tsc: typeof ts) => (props: set.IProps) =>
-        check_union_array_like(tsc)<Metadata>({
-            size: (input) => IdentifierFactory.access(tsc)(input)("size"),
+    export const set = (props: set.IProps) =>
+        check_union_array_like<Metadata, MetadataArray, Metadata>({
+            transform: (value: Metadata) =>
+                MetadataArray.create({
+                    name: `Set<${value.getName()}>`,
+                    index: null,
+                    recursive: false,
+                    nullables: [],
+                    value,
+                }),
+            element: (array) => array.value,
+            size: (input) => IdentifierFactory.access(input)("size"),
             front: (input) =>
-                IdentifierFactory.access(tsc)(
-                    tsc.factory.createCallExpression(
-                        IdentifierFactory.access(tsc)(
-                            tsc.factory.createCallExpression(
-                                IdentifierFactory.access(tsc)(input)("values"),
+                IdentifierFactory.access(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(input)("values"),
                                 undefined,
                                 undefined,
                             ),
@@ -210,25 +229,34 @@ export namespace UnionExplorer {
                     ),
                 )("value"),
             array: (input) =>
-                tsc.factory.createArrayLiteralExpression(
-                    [tsc.factory.createSpreadElement(input)],
+                ts.factory.createArrayLiteralExpression(
+                    [ts.factory.createSpreadElement(input)],
                     false,
                 ),
-            name: (t) => `Set<${t.getName()}>`,
+            name: (_m, e) => `Set<${e.getName()}>`,
         })(props);
     export namespace set {
-        export type IProps = check_union_array_like.IProps<Metadata>;
+        export type IProps = check_union_array_like.IProps<
+            MetadataArray,
+            Metadata
+        >;
     }
 
-    export const map = (tsc: typeof ts) => (props: map.IProps) =>
-        check_union_array_like(tsc)<[Metadata, Metadata]>({
-            size: (input) => IdentifierFactory.access(tsc)(input)("size"),
+    export const map = (props: map.IProps) =>
+        check_union_array_like<
+            Metadata.Entry,
+            MetadataArray,
+            [Metadata, Metadata]
+        >({
+            element: (array) =>
+                array.value.tuples[0]!.elements as [Metadata, Metadata],
+            size: (input) => IdentifierFactory.access(input)("size"),
             front: (input) =>
-                IdentifierFactory.access(tsc)(
-                    tsc.factory.createCallExpression(
-                        IdentifierFactory.access(tsc)(
-                            tsc.factory.createCallExpression(
-                                IdentifierFactory.access(tsc)(input)("entries"),
+                IdentifierFactory.access(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(input)("entries"),
                                 undefined,
                                 undefined,
                             ),
@@ -238,44 +266,36 @@ export namespace UnionExplorer {
                     ),
                 )("value"),
             array: (input) =>
-                tsc.factory.createArrayLiteralExpression(
-                    [tsc.factory.createSpreadElement(input)],
+                ts.factory.createArrayLiteralExpression(
+                    [ts.factory.createSpreadElement(input)],
                     false,
                 ),
-            name: ([k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
+            name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
+            transform: (m: Metadata.Entry) =>
+                MetadataArray.create({
+                    name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+                    index: null,
+                    recursive: false,
+                    nullables: [],
+                    value: Metadata.create({
+                        ...Metadata.initialize(),
+                        tuples: [
+                            MetadataTuple.create({
+                                name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                                index: null,
+                                recursive: false,
+                                nullables: [],
+                                elements: [m.key, m.value],
+                            }),
+                        ],
+                    }),
+                }),
         })(props);
 
     export namespace map {
         export type IProps = check_union_array_like.IProps<
+            MetadataArray,
             [Metadata, Metadata]
         >;
     }
-
-    // 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/helpers/UnionPredicator.ts

@@ -52,7 +52,7 @@ export namespace UnionPredicator {
                 const unique: boolean =
                     neighbors.length === 0 ||
                     neighbors.every(
-                        (n) => !Metadata.intersects(prop.value, n.value, false),
+                        (n) => !Metadata.intersects(prop.value, n.value),
                     );
                 if (unique === true)
                     children.push({

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { FunctionImporter } from "./FunctionImporeter";
 
@@ -13,6 +13,11 @@ const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
     hasLocal: (name: string): boolean => importer.hasLocal(name),
     declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
     increment: (): number => importer.increment(),
+    emplaceUnion: (
+        prefix: string,
+        name: string,
+        factory: () => ts.ArrowFunction,
+    ): string => importer.emplaceUnion(prefix, name, factory),
     trace: (): void => importer.trace(),
 });
 

package/src/programmers/internal/JSON_SCHEMA_PREFIX.ts

@@ -1 +1 @@
-export const JSON_SCHEMA_PREFIX = "#/components/schemas";
+export const JSON_COMPONENTS_PREFIX = "#/components";

package/src/programmers/internal/application_array.ts

@@ -1,8 +1,9 @@
-import { Metadata } from "../../metadata/Metadata";
+import { MetadataArray } from "../../metadata/MetadataArray";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
 import { application_schema } from "./application_schema";
 
 /**
@@ -11,22 +12,53 @@ import { application_schema } from "./application_schema";
 export const application_array =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (tuple?: IJsonSchema.ITuple) =>
-    (metadata: Metadata) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray => {
+    (array: MetadataArray) =>
+    (attribute: IJsonSchema.IAttribute) =>
+    (
+        nullable: boolean,
+    ):
+        | IJsonSchema.IArray
+        | IJsonSchema.IReference
+        | IJsonSchema.IRecursiveReference => {
         // SCHEMA
-        const output: IJsonSchema.IArray = {
-            ...attribute,
-            type: "array",
-            items: application_schema(options)(false)(components)(metadata)(
-                attribute,
-            ),
-            "x-typia-tuple": tuple,
+        const generator = () => {
+            const schema: IJsonSchema.IArray = {
+                ...attribute,
+                type: "array",
+                items: application_schema(options)(false)(components)(
+                    array.value,
+                )(array.recursive ? {} : attribute),
+            };
+            if (array.recursive === false) {
+                for (const tag of attribute["x-typia-metaTags"] ?? [])
+                    if (tag.kind === "minItems") schema.minItems = tag.value;
+                    else if (tag.kind === "maxItems")
+                        schema.maxItems = tag.value;
+            }
+            return schema;
         };
+        if (array.recursive === false) return generator();
 
-        // RANGE
-        for (const tag of attribute["x-typia-metaTags"] ?? [])
-            if (tag.kind === "minItems") output.minItems = tag.value;
-            else if (tag.kind === "maxItems") output.maxItems = tag.value;
-        return output;
+        // KEY
+        const key: string =
+            options.purpose === "ajv"
+                ? array.name
+                : `${array.name}${nullable ? ".Nullable" : ""}`;
+        const $id: string = `${JSON_COMPONENTS_PREFIX}/arrays/${key}`;
+
+        // REFERENCE
+        if (components.arrays?.[key] === undefined) {
+            components.arrays ??= {};
+            components.arrays[key] = {} as any;
+
+            const repeated: IJsonComponents.IArray = {
+                ...generator(),
+                $id: options.purpose === "ajv" ? $id : undefined,
+                $recursiveAnchor: options.purpose === "ajv" || undefined,
+            };
+            components.arrays[key] = repeated;
+        }
+        return options.purpose === "ajv" && array.recursive
+            ? { ...attribute, $recursiveRef: $id }
+            : { ...attribute, $ref: $id };
     };

package/src/programmers/internal/application_boolean.ts

@@ -9,7 +9,7 @@ export const application_boolean = (
 ): IJsonSchema.IBoolean => ({
     ...attribute,
     default: application_default(attribute)(
-        (def) => def === "true" || def === "false",
+        (alias) => alias === "true" || alias === "false",
     )((str) => Boolean(str)),
     type: "boolean",
 });

package/src/programmers/internal/application_constant.ts

@@ -12,8 +12,8 @@ export const application_constant =
         ...attribute,
         type: constant.type,
         enum: constant.values as any,
-        default: application_default(attribute)((def) =>
-            constant.values.some((v) => v.toString() === def),
+        default: application_default(attribute)((alias) =>
+            constant.values.some((v) => v.toString() === alias),
         )(
             constant.type === "string"
                 ? (str) => str

package/src/programmers/internal/application_default.ts

@@ -10,8 +10,8 @@ export const application_default =
         const defaults = (attribute["x-typia-jsDocTags"] ?? []).filter(
             (tag) => tag.name === "default",
         );
-        for (const def of defaults)
-            if (def.text?.length && pred(def.text[0]!.text))
-                return caster(def.text[0]!.text);
+        for (const alias of defaults)
+            if (alias.text?.length && pred(alias.text[0]!.text))
+                return caster(alias.text[0]!.text);
         return undefined;
     };

package/src/programmers/internal/application_definition.ts

@@ -0,0 +1,45 @@
+import { MetadataAlias } from "../../metadata/MetadataAlias";
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+
+import { IJsonSchema } from "../../module";
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
+import { application_schema } from "./application_schema";
+
+export const application_definition =
+    (options: ApplicationProgrammer.IOptions) =>
+    <BlockNever extends boolean>(blockNever: BlockNever) =>
+    (components: IJsonComponents) =>
+    (alias: MetadataAlias) =>
+    (
+        nullable: boolean,
+    ): IJsonSchema.IReference | IJsonSchema.IRecursiveReference => {
+        const key: string =
+            options.purpose === "ajv"
+                ? alias.name
+                : `${alias.name}${nullable ? ".Nullable" : ""}`;
+        const $id: string = `${JSON_COMPONENTS_PREFIX}/aliases/${key}`;
+
+        // TEMPORARY ASSIGNMENT
+        if (components.aliases?.[key] === undefined) {
+            components.aliases ??= {};
+            components.aliases[key] = {
+                $id: key,
+            } as any;
+
+            // GENERATE SCHEM
+            const schema: IJsonSchema = application_schema(options)(blockNever)(
+                components,
+            )(alias.value)({})!;
+            components.aliases ??= {};
+            components.aliases[key] = {
+                $id: options.purpose === "ajv" ? $id : undefined,
+                $recursiveAnchor:
+                    (options.purpose === "ajv" && alias.recursive) || undefined,
+                ...schema,
+            };
+        }
+        return options.purpose === "ajv" && alias.recursive
+            ? { $recursiveRef: $id }
+            : { $ref: $id };
+    };

package/src/programmers/internal/application_native.ts

@@ -2,7 +2,7 @@ import { IJsonComponents } from "../../schemas/IJsonComponents";
 
 import { IJsonSchema } from "../../module";
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
-import { JSON_SCHEMA_PREFIX } from "./JSON_SCHEMA_PREFIX";
+import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
 
 /**
  * @internal
@@ -19,18 +19,21 @@ export const application_native =
             options.purpose === "ajv"
                 ? name
                 : `${name}${props.nullable ? ".Nullable" : ""}`;
-        components.schemas[key] ??= {
-            type: "object",
-            $id:
-                options.purpose === "ajv"
-                    ? `${JSON_SCHEMA_PREFIX}/${key}`
-                    : undefined,
-            properties: {},
-            nullable:
-                options.purpose === "swagger" ? props.nullable : undefined,
-        };
+        if (components.objects?.[key] === undefined) {
+            components.objects ??= {};
+            components.objects[key] ??= {
+                type: "object",
+                $id:
+                    options.purpose === "ajv"
+                        ? `${JSON_COMPONENTS_PREFIX}/objects/${key}`
+                        : undefined,
+                properties: {},
+                nullable:
+                    options.purpose === "swagger" ? props.nullable : undefined,
+            };
+        }
         return {
             ...props.attribute,
-            $ref: `${JSON_SCHEMA_PREFIX}/${key}`,
+            $ref: `${JSON_COMPONENTS_PREFIX}/objects/${key}`,
         };
     };

package/src/programmers/internal/application_object.ts

@@ -9,7 +9,7 @@ import { PatternUtil } from "../../utils/PatternUtil";
 
 import { IJsonSchema } from "../../module";
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
-import { JSON_SCHEMA_PREFIX } from "./JSON_SCHEMA_PREFIX";
+import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
 import { application_schema } from "./application_schema";
 import { metadata_to_pattern } from "./metadata_to_pattern";
 
@@ -20,15 +20,23 @@ export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (obj: MetadataObject) =>
-    (nullable: boolean): string => {
-        const key =
+    (
+        nullable: boolean,
+    ): IJsonSchema.IReference | IJsonSchema.IRecursiveReference => {
+        const key: string =
             options.purpose === "ajv"
                 ? obj.name
                 : `${obj.name}${nullable ? ".Nullable" : ""}`;
+        const $id: string = `${JSON_COMPONENTS_PREFIX}/objects/${key}`;
+        const out = () =>
+            options.purpose === "ajv" && obj.recursive
+                ? { $recursiveRef: $id }
+                : { $ref: $id };
 
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[key] !== undefined) return key;
-        components.schemas[key] = {} as any;
+        if (components.objects?.[key] !== undefined) return out();
+        components.objects ??= {};
+        components.objects[key] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -59,10 +67,10 @@ export const application_object =
                     const info: IJsDocTagInfo | undefined =
                         property.jsDocTags.find((tag) => tag.name === "title");
                     return info?.text?.length
-                        ? CommentFactory.string(info.text)
+                        ? CommentFactory.merge(info.text)
                         : undefined;
                 })(),
-                description: property.description,
+                description: property.description ?? undefined,
                 "x-typia-metaTags": property.tags.length
                     ? property.tags
                     : undefined,
@@ -103,10 +111,7 @@ export const application_object =
             })(),
         };
         const schema: IJsonComponents.IObject = {
-            $id:
-                options.purpose === "ajv"
-                    ? `${JSON_SCHEMA_PREFIX}/${key}`
-                    : undefined,
+            $id: options.purpose === "ajv" ? $id : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
             type: "object",
@@ -126,8 +131,8 @@ export const application_object =
                           join(options)(components)(extraMeta),
                   }),
         };
-        components.schemas[key] = schema;
-        return key;
+        components.objects[key] = schema;
+        return out();
     };
 
 const join =