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

package/src/programmers/internal/application_schema.ts

@@ -4,10 +4,10 @@ import { IJsonSchema } from "../../schemas/IJsonSchema";
 
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { JSON_SCHEMA_PREFIX } from "./JSON_SCHEMA_PREFIX";
 import { application_array } from "./application_array";
 import { application_boolean } from "./application_boolean";
 import { application_constant } from "./application_constant";
+import { application_definition } from "./application_definition";
 import { application_native } from "./application_native";
 import { application_number } from "./application_number";
 import { application_object } from "./application_object";
@@ -47,11 +47,13 @@ export const application_schema =
 
         const insert =
             meta.nullable && options.purpose === "swagger"
-                ? (significant: IJsonSchema.ISignificant<any>) =>
+                ? (s: IJsonSchema) =>
                       union.push({
-                          ...significant,
-                          nullable: true,
-                      })
+                          ...s,
+                          nullable: (s as IJsonSchema.ISignificant<any>).type
+                              ? true
+                              : undefined,
+                      } as IJsonSchema)
                 : (schema: IJsonSchema) => union.push(schema);
 
         // toJSON() METHOD
@@ -86,34 +88,20 @@ export const application_schema =
                 );
 
         // ARRAY
-        for (const schema of meta.arrays.values())
-            insert(application_array(options)(components)()(schema)(attribute));
+        for (const array of meta.arrays)
+            insert(
+                application_array(options)(components)(array)(attribute)(
+                    meta.nullable,
+                ),
+            );
 
         // TUPLE
-        for (const items of meta.tuples) {
-            const tuple: IJsonSchema.ITuple =
-                application_tuple(options)(components)(items)(attribute);
-            if (options.purpose === "swagger" && items.length === 0)
-                throw new Error(
-                    "Error on typia.application(): swagger does not support zero length tuple type.",
-                );
-            else if (
-                options.purpose === "ajv" &&
-                !items[items.length - 1]?.rest
-            )
-                insert(tuple);
-            else {
-                // SWAGGER DOES NOT SUPPORT TUPLE TYPE YET
-                const merged: Metadata = items.reduce((x, y) =>
-                    Metadata.merge(x, y),
-                );
-                insert(
-                    application_array(options)(components)(tuple)(merged)(
-                        attribute,
-                    ),
-                );
-            }
-        }
+        for (const tuple of meta.tuples)
+            insert(
+                application_tuple(options)(components)(tuple)(attribute)(
+                    meta.nullable,
+                ),
+            );
 
         // NATIVES
         for (const native of meta.natives)
@@ -126,21 +114,21 @@ export const application_schema =
                         : application_number(attribute),
                 );
             else
-                union.push(
+                insert(
                     application_native(options)(components)(native)({
                         nullable: meta.nullable,
                         attribute,
                     }),
                 );
         if (meta.sets.length)
-            union.push(
+            insert(
                 application_native(options)(components)(`Set`)({
                     nullable: meta.nullable,
                     attribute,
                 }),
             );
         if (meta.maps.length)
-            union.push(
+            insert(
                 application_native(options)(components)(`Map`)({
                     nullable: meta.nullable,
                     attribute,
@@ -148,16 +136,16 @@ export const application_schema =
             );
 
         // OBJECT
-        for (const obj of meta.objects) {
-            const key: string = application_object(options)(components)(obj)(
-                meta.nullable,
-            );
-            union.push(
-                (options.purpose === "ajv" && obj.recursive
-                    ? recursive
-                    : reference)(`${JSON_SCHEMA_PREFIX}/${key}`, attribute),
+        for (const obj of meta.objects)
+            insert(application_object(options)(components)(obj)(meta.nullable));
+
+        // ALIASES
+        for (const alias of meta.aliases)
+            insert(
+                application_definition(options)(blockNever)(components)(alias)(
+                    meta.nullable,
+                ),
             );
-        }
 
         //----
         // RETURNS
@@ -173,26 +161,4 @@ export const application_schema =
         return { oneOf: union, ...attribute };
     };
 
-/**
- * @internal
- */
-const reference = (
-    $ref: string,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IReference => ({
-    $ref,
-    ...attribute,
-});
-
-/**
- * @internal
- */
-const recursive = (
-    $recursiveRef: string,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IRecursiveReference => ({
-    $recursiveRef,
-    ...attribute,
-});
-
 const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/application_tuple.ts

@@ -1,8 +1,10 @@
 import { Metadata } from "../../metadata/Metadata";
+import { MetadataTuple } from "../../metadata/MetadataTuple";
 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,17 +13,65 @@ import { application_schema } from "./application_schema";
 export const application_tuple =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (items: Array<Metadata>) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema.ITuple => ({
-        type: "array",
-        items: items.map((meta, i) =>
-            application_schema(options)(false)(components)(meta.rest ?? meta)({
+    (tuple: MetadataTuple) =>
+    (attribute: IJsonSchema.IAttribute) =>
+    (
+        nullable: boolean,
+    ):
+        | IJsonSchema.ITuple
+        | IJsonSchema.IArray
+        | IJsonSchema.IReference
+        | IJsonSchema.IRecursiveReference => {
+        const generator = () => {
+            const schema: IJsonSchema.ITuple = {
                 ...attribute,
-                "x-typia-rest":
-                    i === items.length - 1 ? meta.rest !== null : undefined,
-                "x-typia-required": meta.required,
-                "x-typia-optional": meta.optional,
-            }),
-        ),
-        ...attribute,
-    });
+                type: "array",
+                items: tuple.elements.map((elem) =>
+                    application_schema(options)(false)(components)(
+                        elem.rest ?? elem,
+                    )(tuple.recursive ? {} : attribute),
+                ),
+                "x-typia-rest": !!tuple.elements.at(-1)?.rest,
+            };
+            const wrapper: IJsonSchema.ITuple | IJsonSchema.IArray =
+                options.purpose === "ajv" && !tuple.elements.at(-1)?.rest
+                    ? schema
+                    : {
+                          ...schema,
+                          items: application_schema(options)(false)(components)(
+                              tuple.elements.reduce(
+                                  (x, y) =>
+                                      Metadata.merge(x.rest ?? x, y.rest ?? y),
+                                  Metadata.initialize(),
+                              ),
+                          )(tuple.recursive ? {} : attribute),
+                          "x-typia-tuple": schema,
+                      };
+            return wrapper;
+        };
+        if (tuple.recursive === false) return generator();
+
+        // KEY
+        const key: string =
+            options.purpose === "ajv"
+                ? tuple.name
+                : `${tuple.name}${nullable ? ".Nullable" : ""}`;
+        const $id: string = `${JSON_COMPONENTS_PREFIX}/tuples/${key}`;
+
+        // REFERENCE
+        if (components.tuples?.[key] === undefined) {
+            components.tuples ??= {};
+            components.tuples[key] = {} as any;
+
+            const repeated: IJsonComponents.IArray | IJsonComponents.ITuple = {
+                ...generator(),
+                $id: options.purpose === "ajv" ? $id : undefined,
+                $recursiveAnchor: options.purpose === "ajv" || undefined,
+            };
+            components.tuples ??= {};
+            components.tuples[key] = repeated;
+        }
+        return options.purpose === "ajv" && tuple.recursive
+            ? { ...attribute, $recursiveRef: $id }
+            : { ...attribute, $ref: $id };
+    };

package/src/programmers/internal/check_array.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
@@ -15,17 +15,16 @@ import { check_custom } from "./check_custom";
  * @internal
  */
 export const check_array =
-    (tsc: typeof ts) =>
     (importer: FunctionImporter) =>
     (metaTags: IMetadataTag[]) =>
     (jsDocTags: IJsDocTagInfo[]) =>
     (input: ts.Expression): ICheckEntry => ({
-        expression: ExpressionFactory.isArray(tsc)(input),
+        expression: ExpressionFactory.isArray(input),
         tags: [
-            ...check_array_length(tsc)(metaTags)(
-                IdentifierFactory.access(tsc)(input)("length"),
+            ...check_array_length(metaTags)(
+                IdentifierFactory.access(input)("length"),
             ),
-            ...check_custom(tsc)("array", "Array")(importer)(jsDocTags)(input),
+            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
             // check custom array for legacy (3.7.0)
         ],
     });

package/src/programmers/internal/check_array_length.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
@@ -6,24 +6,24 @@ import { IMetadataTag } from "../../metadata/IMetadataTag";
  * @internal
  */
 export const check_array_length =
-    (tsc: typeof ts) => (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
+    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
         metaTags
             .map((tag) => ({
                 tag,
                 expression:
                     tag.kind === "items"
-                        ? tsc.factory.createStrictEquality(
-                              tsc.factory.createNumericLiteral(tag.value),
+                        ? ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(tag.value),
                               input,
                           )
                         : tag.kind === "minItems"
-                        ? tsc.factory.createLessThanEquals(
-                              tsc.factory.createNumericLiteral(tag.value),
+                        ? ts.factory.createLessThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
                               input,
                           )
                         : tag.kind === "maxItems"
-                        ? tsc.factory.createGreaterThanEquals(
-                              tsc.factory.createNumericLiteral(tag.value),
+                        ? ts.factory.createGreaterThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
                               input,
                           )
                         : null!,

package/src/programmers/internal/check_bigint.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
@@ -11,7 +11,6 @@ import { check_custom } from "./check_custom";
  * @internal
  */
 export const check_bigint =
-    (tsc: typeof ts) =>
     (importer: FunctionImporter) =>
     (metaTags: IMetadataTag[]) =>
     (jsDocTag: IJsDocTagInfo[]) =>
@@ -21,16 +20,13 @@ export const check_bigint =
             if (tag.kind === "multipleOf")
                 entries.push([
                     tag,
-                    tsc.factory.createStrictEquality(
-                        cast(tsc)(0),
-                        tsc.factory.createModulo(input, cast(tsc)(tag.value)),
+                    ts.factory.createStrictEquality(
+                        cast(0),
+                        ts.factory.createModulo(input, cast(tag.value)),
                     ),
                 ]);
             else if (tag.kind === "step") {
-                const modulo = tsc.factory.createModulo(
-                    input,
-                    cast(tsc)(tag.value),
-                );
+                const modulo = ts.factory.createModulo(input, cast(tag.value));
                 const minimum =
                     (metaTags.find(
                         (tag) =>
@@ -39,57 +35,48 @@ export const check_bigint =
                     )?.value as number | undefined) ?? undefined;
                 entries.push([
                     tag,
-                    tsc.factory.createStrictEquality(
-                        cast(tsc)(0),
+                    ts.factory.createStrictEquality(
+                        cast(0),
                         minimum !== undefined
-                            ? tsc.factory.createSubtract(
-                                  modulo,
-                                  cast(tsc)(minimum),
-                              )
+                            ? ts.factory.createSubtract(modulo, cast(minimum))
                             : modulo,
                     ),
                 ]);
             } else if (tag.kind === "minimum")
                 entries.push([
                     tag,
-                    tsc.factory.createLessThanEquals(
-                        cast(tsc)(tag.value),
-                        input,
-                    ),
+                    ts.factory.createLessThanEquals(cast(tag.value), input),
                 ]);
             else if (tag.kind === "maximum")
                 entries.push([
                     tag,
-                    tsc.factory.createGreaterThanEquals(
-                        cast(tsc)(tag.value),
-                        input,
-                    ),
+                    ts.factory.createGreaterThanEquals(cast(tag.value), input),
                 ]);
             else if (tag.kind === "exclusiveMinimum")
                 entries.push([
                     tag,
-                    tsc.factory.createLessThan(cast(tsc)(tag.value), input),
+                    ts.factory.createLessThan(cast(tag.value), input),
                 ]);
             else if (tag.kind === "exclusiveMaximum")
                 entries.push([
                     tag,
-                    tsc.factory.createGreaterThan(cast(tsc)(tag.value), input),
+                    ts.factory.createGreaterThan(cast(tag.value), input),
                 ]);
         }
         return {
-            expression: tsc.factory.createStrictEquality(
-                tsc.factory.createStringLiteral("bigint"),
-                tsc.factory.createTypeOfExpression(input),
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("bigint"),
+                ts.factory.createTypeOfExpression(input),
             ),
             tags: [
                 ...entries.map(([tag, expression]) => ({
                     expected: `bigint (@${tag.kind} ${tag.value})`,
                     expression,
                 })),
-                ...check_custom(tsc)("bigint")(importer)(jsDocTag)(input),
+                ...check_custom("bigint")(importer)(jsDocTag)(input),
             ],
         };
     };
 
-const cast = (tsc: typeof ts) => (value: number) =>
-    tsc.factory.createIdentifier(`${Math.floor(value)}n`);
+const cast = (value: number) =>
+    ts.factory.createIdentifier(`${Math.floor(value)}n`);

package/src/programmers/internal/check_custom.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 
@@ -10,7 +10,6 @@ import { get_comment_tags } from "./get_comment_tags";
  * @internal
  */
 export const check_custom =
-    (tsc: typeof ts) =>
     (type: string, alias?: string) =>
     (importer: FunctionImporter) =>
     (jsDocTags: IJsDocTagInfo[]) =>
@@ -19,13 +18,13 @@ export const check_custom =
             expected: `${alias ?? type} (@${tag.name}${
                 tag.value?.length ? ` ${tag.value}` : ""
             })`,
-            expression: tsc.factory.createCallExpression(
+            expression: ts.factory.createCallExpression(
                 importer.use("is_custom"),
                 undefined,
                 [
-                    tsc.factory.createStringLiteral(tag.name),
-                    tsc.factory.createStringLiteral(type),
-                    tsc.factory.createStringLiteral(tag.value ?? ""),
+                    ts.factory.createStringLiteral(tag.name),
+                    ts.factory.createStringLiteral(type),
+                    ts.factory.createStringLiteral(tag.value ?? ""),
                     input,
                 ],
             ),

package/src/programmers/internal/check_dynamic_properties.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
@@ -13,7 +13,6 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  * @internal
  */
 export const check_dynamic_properties =
-    (tsc: typeof ts) =>
     (props: check_object.IProps) =>
     (importer: FunctionImporter) =>
     (
@@ -21,9 +20,9 @@ export const check_dynamic_properties =
         regular: IExpressionEntry<ts.Expression>[],
         dynamic: IExpressionEntry<ts.Expression>[],
     ): ts.Expression => {
-        const length = IdentifierFactory.access(tsc)(
-            tsc.factory.createCallExpression(
-                tsc.factory.createIdentifier("Object.keys"),
+        const length = IdentifierFactory.access(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.keys"),
                 undefined,
                 [input],
             ),
@@ -32,21 +31,21 @@ export const check_dynamic_properties =
             props.equals === true && dynamic.length === 0
                 ? props.undefined === true ||
                   regular.every((r) => r.meta.required)
-                    ? tsc.factory.createStrictEquality(
-                          tsc.factory.createNumericLiteral(
+                    ? ts.factory.createStrictEquality(
+                          ts.factory.createNumericLiteral(
                               regular.filter((r) => r.meta.required).length,
                           ),
                           length,
                       )
-                    : tsc.factory.createCallExpression(
+                    : ts.factory.createCallExpression(
                           importer.use("is_between"),
                           [],
                           [
                               length,
-                              tsc.factory.createNumericLiteral(
+                              ts.factory.createNumericLiteral(
                                   regular.filter((r) => r.meta.required).length,
                               ),
-                              tsc.factory.createNumericLiteral(regular.length),
+                              ts.factory.createNumericLiteral(regular.length),
                           ],
                       )
                 : null;
@@ -58,37 +57,36 @@ export const check_dynamic_properties =
             return left;
 
         const criteria = props.entries
-            ? tsc.factory.createCallExpression(props.entries, undefined, [
-                  tsc.factory.createCallExpression(
-                      tsc.factory.createIdentifier("Object.keys"),
+            ? ts.factory.createCallExpression(props.entries, undefined, [
+                  ts.factory.createCallExpression(
+                      ts.factory.createIdentifier("Object.keys"),
                       undefined,
                       [input],
                   ),
-                  check_dynamic_property(tsc)(props)(input, regular, dynamic),
+                  check_dynamic_property(props)(input, regular, dynamic),
               ])
-            : tsc.factory.createCallExpression(
-                  IdentifierFactory.access(tsc)(
-                      tsc.factory.createCallExpression(
-                          tsc.factory.createIdentifier("Object.keys"),
+            : ts.factory.createCallExpression(
+                  IdentifierFactory.access(
+                      ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("Object.keys"),
                           undefined,
                           [input],
                       ),
                   )(props.assert ? "every" : "map"),
                   undefined,
-                  [check_dynamic_property(tsc)(props)(input, regular, dynamic)],
+                  [check_dynamic_property(props)(input, regular, dynamic)],
               );
         const right: ts.Expression = (props.halt || ((elem) => elem))(
-            props.assert ? criteria : check_everything(tsc)(criteria),
+            props.assert ? criteria : check_everything(criteria),
         );
         return left
             ? (props.undefined
-                  ? tsc.factory.createLogicalOr
-                  : tsc.factory.createLogicalAnd)(left, right)
+                  ? ts.factory.createLogicalOr
+                  : ts.factory.createLogicalAnd)(left, right)
             : right;
     };
 
 const check_dynamic_property =
-    (tsc: typeof ts) =>
     (props: check_object.IProps) =>
     (
         input: ts.Expression,
@@ -99,31 +97,31 @@ const check_dynamic_property =
         // IF CONDITIONS
         //----
         // PREPARE ASSETS
-        const key = tsc.factory.createIdentifier("key");
-        const value = tsc.factory.createIdentifier("value");
+        const key = ts.factory.createIdentifier("key");
+        const value = ts.factory.createIdentifier("value");
 
         const statements: ts.Statement[] = [];
         const add = (exp: ts.Expression, output: ts.Expression) =>
             statements.push(
-                tsc.factory.createIfStatement(
+                ts.factory.createIfStatement(
                     exp,
-                    tsc.factory.createReturnStatement(output),
+                    ts.factory.createReturnStatement(output),
                 ),
             );
 
         // GATHER CONDITIONS
         if (props.equals === true && regular.length)
-            add(is_regular_property(tsc)(regular), props.positive);
+            add(is_regular_property(regular), props.positive);
         statements.push(
-            StatementFactory.constant(tsc)(
+            StatementFactory.constant(
                 "value",
-                tsc.factory.createElementAccessExpression(input, key),
+                ts.factory.createElementAccessExpression(input, key),
             ),
         );
         if (props.undefined === true)
             add(
-                tsc.factory.createStrictEquality(
-                    tsc.factory.createIdentifier("undefined"),
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("undefined"),
                     value,
                 ),
                 props.positive,
@@ -131,8 +129,8 @@ const check_dynamic_property =
 
         for (const entry of dynamic)
             add(
-                tsc.factory.createCallExpression(
-                    tsc.factory.createIdentifier(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
                         `RegExp(/${metadata_to_pattern(true)(
                             entry.key,
                         )}/).test`,
@@ -147,10 +145,10 @@ const check_dynamic_property =
         // FUNCTION BODY
         //----
         // CLOSURE BLOCK
-        const block: ts.Block = tsc.factory.createBlock(
+        const block: ts.Block = ts.factory.createBlock(
             [
                 ...statements,
-                tsc.factory.createReturnStatement(
+                ts.factory.createReturnStatement(
                     props.equals === true
                         ? props.superfluous(value)
                         : props.positive,
@@ -160,38 +158,36 @@ const check_dynamic_property =
         );
 
         // RETURNS
-        return tsc.factory.createArrowFunction(
+        return ts.factory.createArrowFunction(
             undefined,
             undefined,
-            [IdentifierFactory.parameter(tsc)("key")],
+            [IdentifierFactory.parameter("key")],
             undefined,
             undefined,
             block,
         );
     };
 
-const is_regular_property = (tsc: typeof ts) => (regular: IExpressionEntry[]) =>
-    tsc.factory.createCallExpression(
-        IdentifierFactory.access(tsc)(
-            tsc.factory.createArrayLiteralExpression(
+const is_regular_property = (regular: IExpressionEntry[]) =>
+    ts.factory.createCallExpression(
+        IdentifierFactory.access(
+            ts.factory.createArrayLiteralExpression(
                 regular.map((entry) =>
-                    tsc.factory.createStringLiteral(
-                        entry.key.getSoleLiteral()!,
-                    ),
+                    ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
                 ),
             ),
         )("some"),
         undefined,
         [
-            tsc.factory.createArrowFunction(
+            ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter(tsc)("prop")],
+                [IdentifierFactory.parameter("prop")],
                 undefined,
                 undefined,
-                tsc.factory.createStrictEquality(
-                    tsc.factory.createIdentifier("key"),
-                    tsc.factory.createIdentifier("prop"),
+                ts.factory.createStrictEquality(
+                    ts.factory.createIdentifier("key"),
+                    ts.factory.createIdentifier("prop"),
                 ),
             ),
         ],