typia 3.8.9 → 3.9.0-dev.20230604

package/src/programmers/ValidateProgrammer.ts

@@ -32,41 +32,48 @@ export namespace ValidateProgrammer {
         (equals: boolean) =>
         (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
-            const program: ts.ArrowFunction = CheckerProgrammer.write(project)({
-                functors: "$vo",
-                unioners: "$vu",
-                path: true,
-                trace: true,
-                numeric: OptionPredicator.numeric(project.options),
-                equals,
-                atomist: (explore) => (tuple) => (input) =>
-                    [
-                        tuple.expression,
-                        ...tuple.tags.map((tag) =>
-                            ts.factory.createLogicalOr(
-                                tag.expression,
-                                create_report_call(
-                                    explore.from === "top"
-                                        ? ts.factory.createTrue()
-                                        : ts.factory.createIdentifier(
-                                              "_exceptionable",
-                                          ),
-                                )(
-                                    ts.factory.createIdentifier(
-                                        explore.postfix
-                                            ? `_path + ${explore.postfix}`
-                                            : "_path",
+
+            const is = IsProgrammer.write(project)(modulo, true)(equals)(
+                type,
+                name ?? TypeFactory.getFullName(project.checker)(type),
+            );
+            const validate: ts.ArrowFunction = CheckerProgrammer.write(project)(
+                {
+                    prefix: "$v",
+                    path: true,
+                    trace: true,
+                    numeric: OptionPredicator.numeric(project.options),
+                    equals,
+                    atomist: (explore) => (tuple) => (input) =>
+                        [
+                            tuple.expression,
+                            ...tuple.tags.map((tag) =>
+                                ts.factory.createLogicalOr(
+                                    tag.expression,
+                                    create_report_call(
+                                        explore.from === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "_exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(
+                                            explore.postfix
+                                                ? `_path + ${explore.postfix}`
+                                                : "_path",
+                                        ),
+                                        tag.expected,
+                                        input,
                                     ),
-                                    tag.expected,
-                                    input,
                                 ),
                             ),
-                        ),
-                    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-                combiner: combine(equals)(importer),
-                joiner: joiner(equals)(importer),
-                success: ts.factory.createTrue(),
-            })(importer)(type, name);
+                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                    combiner: combine(equals)(importer),
+                    joiner: joiner(equals)(importer),
+                    success: ts.factory.createTrue(),
+                    addition: () => importer.declare(modulo),
+                },
+            )(importer)(type, name);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -85,16 +92,6 @@ export namespace ValidateProgrammer {
                 undefined,
                 ts.factory.createBlock(
                     [
-                        StatementFactory.constant(
-                            "__is",
-                            IsProgrammer.write(project)(modulo, true)(equals)(
-                                type,
-                                name ??
-                                    TypeFactory.getFullName(project.checker)(
-                                        type,
-                                    ),
-                            ),
-                        ),
                         StatementFactory.constant(
                             "errors",
                             ts.factory.createAsExpression(
@@ -119,7 +116,7 @@ export namespace ValidateProgrammer {
                                 [ts.factory.createIdentifier("errors")],
                             ),
                         ),
-                        ...importer.declare(modulo),
+                        StatementFactory.constant("__is", is),
                         ts.factory.createIfStatement(
                             ts.factory.createStrictEquality(
                                 ts.factory.createFalse(),
@@ -131,7 +128,7 @@ export namespace ValidateProgrammer {
                             ),
                             ts.factory.createExpressionStatement(
                                 ts.factory.createCallExpression(
-                                    program,
+                                    validate,
                                     undefined,
                                     [
                                         ts.factory.createIdentifier("input"),

package/src/programmers/helpers/FunctionImporeter.ts

@@ -7,6 +7,8 @@ import { TypeFactory } from "../../factories/TypeFactory";
 export class FunctionImporter {
     private readonly used_: Set<string> = new Set();
     private readonly local_: Set<string> = new Set();
+    private readonly unions_: Map<string, [string, ts.ArrowFunction]> =
+        new Map();
     private sequence_: number = 0;
 
     public empty(): boolean {
@@ -28,25 +30,47 @@ export class FunctionImporter {
     }
 
     public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
-        return [...this.used_].map((name) =>
-            StatementFactory.constant(
-                "$" + name,
-                IdentifierFactory.access(
-                    ts.factory.createParenthesizedExpression(
-                        ts.factory.createAsExpression(
-                            modulo,
-                            TypeFactory.keyword("any"),
+        return [
+            ...[...this.used_].map((name) =>
+                StatementFactory.constant(
+                    "$" + name,
+                    IdentifierFactory.access(
+                        ts.factory.createParenthesizedExpression(
+                            ts.factory.createAsExpression(
+                                modulo,
+                                TypeFactory.keyword("any"),
+                            ),
                         ),
-                    ),
-                )(name),
+                    )(name),
+                ),
             ),
-        );
+            ...[...this.unions_.values()].map(([key, arrow]) =>
+                StatementFactory.constant(key, arrow),
+            ),
+        ];
     }
 
     public increment(): number {
         return ++this.sequence_;
     }
 
+    public emplaceUnion(
+        prefix: string,
+        name: string,
+        factory: () => ts.ArrowFunction,
+    ): string {
+        const oldbie = this.unions_.get(name);
+        if (oldbie) return oldbie[0];
+
+        const index: number = this.unions_.size;
+        const accessor: string = `${prefix}p${index}`;
+
+        const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
+        this.unions_.set(name, tuple);
+        tuple[1] = factory();
+        return accessor;
+    }
+
     public trace(): void {
         console.log(...this.used_);
         console.log(...this.local_);

package/src/programmers/helpers/RandomJoiner.ts

@@ -12,7 +12,6 @@ import { MetadataProperty } from "../../metadata/MetadataProperty";
 import { Escaper } from "../../utils/Escaper";
 
 import { get_comment_tags } from "../internal/get_comment_tags";
-import { RandomRanger } from "./RandomRanger";
 
 export namespace RandomJoiner {
     export type Decoder = (
@@ -24,17 +23,14 @@ export namespace RandomJoiner {
     export const array =
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
-        (item: Metadata, tags: IMetadataTag[], comments: ICommentTag[]) => {
-            const tail = RandomRanger.length(coalesce)({
-                minimum: 0,
-                maximum: 3,
-                gap: 3,
-            })({
-                fixed: "items",
-                minimum: "minItems",
-                maximum: "maxItems",
-            })(tags);
-            return ts.factory.createCallExpression(
+        (explore: IExplore) =>
+        (length: ts.Expression | undefined) =>
+        (
+            item: Metadata,
+            tags: IMetadataTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
+            const generator: ts.Expression = ts.factory.createCallExpression(
                 coalesce("array"),
                 undefined,
                 [
@@ -46,9 +42,20 @@ export namespace RandomJoiner {
                         undefined,
                         decoder(item, tags, comments),
                     ),
-                    ...(tail ? [tail] : []),
+                    ...(length ? [length] : []),
                 ],
             );
+            if (explore.recursive === false) return generator;
+            return ts.factory.createConditionalExpression(
+                ts.factory.createGreaterThanEquals(
+                    ts.factory.createNumericLiteral(5),
+                    ts.factory.createIdentifier("_depth"),
+                ),
+                undefined,
+                generator,
+                undefined,
+                ts.factory.createArrayLiteralExpression([]),
+            );
         };
 
     export const tuple =
@@ -159,3 +166,8 @@ export namespace RandomJoiner {
                 ),
             ]);
 }
+
+interface IExplore {
+    function: boolean;
+    recursive: boolean;
+}

package/src/programmers/helpers/UnionExplorer.ts

@@ -5,7 +5,9 @@ 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";
@@ -37,7 +39,7 @@ export namespace UnionExplorer {
         ): ts.Expression => {
             // BREAKER
             if (targets.length === 1)
-                return config.objector.decoder(
+                return config.objector.decoder()(
                     input,
                     targets[0]!,
                     explore,
@@ -78,7 +80,7 @@ export namespace UnionExplorer {
                     const accessor: ts.Expression =
                         IdentifierFactory.access(input)(key);
                     const pred: ts.Expression = spec.neighbour
-                        ? config.objector.checker(
+                        ? config.objector.checker()(
                               accessor,
                               spec.property.value,
                               {
@@ -95,7 +97,7 @@ export namespace UnionExplorer {
                     return ts.factory.createIfStatement(
                         (config.objector.is || ((exp) => exp))(pred),
                         ts.factory.createReturnStatement(
-                            config.objector.decoder(
+                            config.objector.decoder()(
                                 input,
                                 spec.object,
                                 explore,
@@ -144,50 +146,73 @@ export namespace UnionExplorer {
     /* -----------------------------------------------------------
         ARRAY LIKE
     ----------------------------------------------------------- */
-    export const tuple = (props: check_union_array_like.IProps<Metadata[]>) =>
-        check_union_array_like<Metadata[]>({
-            size: null,
+    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: (elems) => `[${elems.map((e) => e.getName()).join(", ")}]`,
+            name: (t) => t.name,
         })(props);
     export namespace tuple {
         export type IProps = check_union_array_like.IProps<
-            Metadata | Metadata[]
+            MetadataTuple,
+            MetadataTuple
         >;
     }
 
     export const array = (props: array.IProps) =>
-        check_union_array_like<Metadata>({
+        check_union_array_like<MetadataArray, MetadataArray, Metadata>({
+            transform: (x) => x,
+            element: (x) => x.value,
             size: (input) => IdentifierFactory.access(input)("length"),
             front: (input) =>
                 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 = (props: array_or_tuple.IProps) =>
-        check_union_array_like<Metadata | Metadata[]>({
+        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: (t) =>
-                Array.isArray(t)
-                    ? `[${t.map((e) => e.getName()).join(", ")}]`
-                    : `Array<${t.getName()}>`,
+            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 = (props: set.IProps) =>
-        check_union_array_like<Metadata>({
+        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(
@@ -208,14 +233,23 @@ export namespace UnionExplorer {
                     [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 = (props: map.IProps) =>
-        check_union_array_like<[Metadata, Metadata]>({
+        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(
@@ -236,40 +270,32 @@ export namespace UnionExplorer {
                     [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

@@ -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 };
+    };