typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/programmers/internal/application_boolean.ts

@@ -4,14 +4,12 @@ import { application_default } from "./application_default";
 /**
  * @internal
  */
-export const application_boolean = (props: {
-    nullable: boolean;
-    attribute: IJsonSchema.IAttribute;
-}): IJsonSchema.IBoolean => ({
-    type: "boolean",
-    nullable: props.nullable,
-    ...props.attribute,
-    default: application_default(props.attribute)(
+export const application_boolean = (
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IBoolean => ({
+    ...attribute,
+    default: application_default(attribute)(
         (def) => def === "true" || def === "false",
     )((str) => Boolean(str)),
+    type: "boolean",
 });

package/src/programmers/internal/application_constant.ts

@@ -8,15 +8,11 @@ import { application_default } from "./application_default";
  */
 export const application_constant =
     (constant: MetadataConstant) =>
-    (props: {
-        nullable: boolean;
-        attribute: IJsonSchema.IAttribute;
-    }): IJsonSchema.IEnumeration<any> => ({
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IEnumeration<any> => ({
+        ...attribute,
         type: constant.type,
         enum: constant.values as any,
-        nullable: props.nullable,
-        ...props.attribute,
-        default: application_default(props.attribute)((def) =>
+        default: application_default(attribute)((def) =>
             constant.values.some((v) => v.toString() === def),
         )(
             constant.type === "string"

package/src/programmers/internal/application_default.ts

@@ -7,7 +7,7 @@ export const application_default =
     (attribute: IJsonSchema.IAttribute) =>
     (pred: (value: string) => boolean) =>
     <T>(caster: (str: string) => T): T | undefined => {
-        const defaults = (attribute["x-typia-jsDocTags"] || []).filter(
+        const defaults = (attribute["x-typia-jsDocTags"] ?? []).filter(
             (tag) => tag.name === "default",
         );
         for (const def of defaults)

package/src/programmers/internal/application_native.ts

@@ -2,6 +2,7 @@ import { IJsonComponents } from "../../schemas/IJsonComponents";
 
 import { IJsonSchema } from "../../module";
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { JSON_SCHEMA_PREFIX } from "./JSON_SCHEMA_PREFIX";
 
 /**
  * @internal
@@ -14,19 +15,22 @@ export const application_native =
         nullable: boolean;
         attribute: IJsonSchema.IAttribute;
     }): IJsonSchema.IReference => {
-        const key: string = name + (props.nullable ? ".Nullable" : "");
-        if (components.schemas[key] === undefined)
-            components.schemas[key] = {
-                type: "object",
-                $id:
-                    options.purpose === "ajv"
-                        ? options.prefix + "/" + key
-                        : undefined,
-                properties: {},
-                nullable: props.nullable,
-            };
+        const key: string =
+            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,
+        };
         return {
-            $ref: `#/components/schemas/${name}`,
             ...props.attribute,
+            $ref: `${JSON_SCHEMA_PREFIX}/${key}`,
         };
     };

package/src/programmers/internal/application_number.ts

@@ -4,16 +4,14 @@ import { application_default } from "./application_default";
 /**
  * @internal
  */
-export const application_number = (props: {
-    nullable: boolean;
-    attribute: IJsonSchema.IAttribute;
-}): IJsonSchema.INumber | IJsonSchema.IInteger => {
+export const application_number = (
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.INumber | IJsonSchema.IInteger => {
     const output: IJsonSchema.INumber | IJsonSchema.IInteger = {
+        ...attribute,
         type: "number" as "number" | "integer",
-        nullable: props.nullable,
-        ...props.attribute,
     };
-    for (const tag of props.attribute["x-typia-metaTags"] || []) {
+    for (const tag of attribute["x-typia-metaTags"] ?? []) {
         // CHECK TYPE
         if (
             tag.kind === "type" &&
@@ -37,7 +35,7 @@ export const application_number = (props: {
     // WHEN UNSIGNED INT
     if (
         output.type === "integer" &&
-        (props.attribute["x-typia-metaTags"] || []).find(
+        (attribute["x-typia-metaTags"] ?? []).find(
             (tag) => tag.kind === "type" && tag.value === "uint",
         )
     )
@@ -52,7 +50,7 @@ export const application_number = (props: {
         }
 
     // DEFAULT CONFIGURATION
-    output.default = application_default(props.attribute)((str) => {
+    output.default = application_default(attribute)((str) => {
         const value: number = Number(str);
         const conditions: boolean[] = [!Number.isNaN(value)];
         if (output.minimum !== undefined)

package/src/programmers/internal/application_object.ts

@@ -9,6 +9,7 @@ import { PatternUtil } from "../../utils/PatternUtil";
 
 import { IJsonSchema } from "../../module";
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { JSON_SCHEMA_PREFIX } from "./JSON_SCHEMA_PREFIX";
 import { application_schema } from "./application_schema";
 import { metadata_to_pattern } from "./metadata_to_pattern";
 
@@ -19,10 +20,15 @@ export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (obj: MetadataObject) =>
-    (props: { key: string; nullable: boolean }): void => {
+    (nullable: boolean): string => {
+        const key =
+            options.purpose === "ajv"
+                ? obj.name
+                : `${obj.name}${nullable ? ".Nullable" : ""}`;
+
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[props.key] !== undefined) return;
-        components.schemas[props.key] = {} as any;
+        if (components.schemas[key] !== undefined) return key;
+        components.schemas[key] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -99,13 +105,13 @@ export const application_object =
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
-                    ? options.prefix + "/" + props.key
+                    ? `${JSON_SCHEMA_PREFIX}/${key}`
                     : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
             type: "object",
             properties,
-            nullable: props.nullable,
+            nullable: options.purpose === "swagger" ? nullable : undefined,
             required: required.length ? required : undefined,
             description: obj.description,
             "x-typia-jsDocTags": obj.jsDocTags,
@@ -120,7 +126,8 @@ export const application_object =
                           join(options)(components)(extraMeta),
                   }),
         };
-        components.schemas[props.key] = schema;
+        components.schemas[key] = schema;
+        return key;
     };
 
 const join =

package/src/programmers/internal/application_schema.ts

@@ -4,6 +4,7 @@ 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";
@@ -38,6 +39,20 @@ export const application_schema =
         // GATHER UNION SCHEMAS
         //----
         const union: IJsonSchema[] = [];
+        if (meta.nullable && options.purpose !== "swagger")
+            union.push({
+                ...attribute,
+                type: "null",
+            });
+
+        const insert =
+            meta.nullable && options.purpose === "swagger"
+                ? (significant: IJsonSchema.ISignificant<any>) =>
+                      union.push({
+                          ...significant,
+                          nullable: true,
+                      })
+                : (schema: IJsonSchema) => union.push(schema);
 
         // toJSON() METHOD
         if (meta.resolved !== null) {
@@ -49,7 +64,7 @@ export const application_schema =
 
         // ATOMIC TYPES
         if (meta.templates.length && AtomicPredicator.template(meta))
-            union.push(application_templates(meta)(attribute));
+            insert(application_templates(meta)(attribute));
         for (const constant of meta.constants)
             if (constant.type === "bigint") throw new Error(NO_BIGINT);
             else if (
@@ -57,48 +72,27 @@ export const application_schema =
                 AtomicPredicator.constant(meta)(constant.type) === false
             )
                 continue;
-            else
-                union.push(
-                    application_constant(constant)({
-                        nullable: meta.nullable,
-                        attribute,
-                    }),
-                );
+            else insert(application_constant(constant)(attribute));
         for (const type of meta.atomics)
             if (type === "bigint") throw new Error(NO_BIGINT);
             else if (AtomicPredicator.atomic(meta)(type) === false) continue;
             else
-                union.push(
+                insert(
                     type === "string"
-                        ? application_string(meta, attribute)
+                        ? application_string(meta)(attribute)
                         : type === "boolean"
-                        ? application_boolean({
-                              nullable: meta.nullable,
-                              attribute,
-                          })
-                        : application_number({
-                              nullable: meta.nullable,
-                              attribute,
-                          }),
+                        ? application_boolean(attribute)
+                        : application_number(attribute),
                 );
 
         // ARRAY
         for (const schema of meta.arrays.values())
-            union.push(
-                application_array(options)(components)()(schema)({
-                    nullable: meta.nullable,
-                    attribute,
-                }),
-            );
+            insert(application_array(options)(components)()(schema)(attribute));
 
         // TUPLE
         for (const items of meta.tuples) {
-            const tuple: IJsonSchema.ITuple = application_tuple(options)(
-                components,
-            )(items)({
-                nullable: meta.nullable,
-                attribute,
-            });
+            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.",
@@ -107,17 +101,16 @@ export const application_schema =
                 options.purpose === "ajv" &&
                 !items[items.length - 1]?.rest
             )
-                union.push(tuple);
+                insert(tuple);
             else {
                 // SWAGGER DOES NOT SUPPORT TUPLE TYPE YET
                 const merged: Metadata = items.reduce((x, y) =>
                     Metadata.merge(x, y),
                 );
-                union.push(
-                    application_array(options)(components)(tuple)(merged)({
-                        nullable: merged?.nullable ?? false,
+                insert(
+                    application_array(options)(components)(tuple)(merged)(
                         attribute,
-                    }),
+                    ),
                 );
             }
         }
@@ -125,18 +118,12 @@ export const application_schema =
         // NATIVES
         for (const native of meta.natives)
             if (AtomicPredicator.native(native))
-                union.push(
+                insert(
                     native === "String"
-                        ? application_string(meta, attribute)
+                        ? application_string(meta)(attribute)
                         : native === "Boolean"
-                        ? application_boolean({
-                              nullable: meta.nullable,
-                              attribute,
-                          })
-                        : application_number({
-                              nullable: meta.nullable,
-                              attribute,
-                          }),
+                        ? application_boolean(attribute)
+                        : application_number(attribute),
                 );
             else
                 union.push(
@@ -162,15 +149,13 @@ export const application_schema =
 
         // OBJECT
         for (const obj of meta.objects) {
-            const key: string = obj.name + (meta.nullable ? ".Nullable" : "");
-            application_object(options)(components)(obj)({
-                key,
-                nullable: meta.nullable,
-            });
+            const key: string = application_object(options)(components)(obj)(
+                meta.nullable,
+            );
             union.push(
                 (options.purpose === "ajv" && obj.recursive
                     ? recursive
-                    : reference)(`${options.prefix}/${key}`, attribute),
+                    : reference)(`${JSON_SCHEMA_PREFIX}/${key}`, attribute),
             );
         }
 

package/src/programmers/internal/application_string.ts

@@ -7,39 +7,38 @@ import { application_default_string } from "./application_default_string";
 /**
  * @internal
  */
-export const application_string = (
-    meta: Metadata,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IString => {
-    const output: IJsonSchema.IString = {
-        type: "string",
-        nullable: meta.nullable,
-        ...attribute,
-    };
+export const application_string =
+    (meta: Metadata) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IString => {
+        const output: IJsonSchema.IString = {
+            ...attribute,
+            type: "string",
+        };
 
-    // FORMAT TAG OF METADATA
-    const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
-        (tag) => tag.name === "format",
-    );
-    if (formatJsdocTag?.text?.length)
-        output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
+        // FORMAT TAG OF METADATA
+        const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
+            (tag) => tag.name === "format",
+        );
+        if (formatJsdocTag?.text?.length)
+            output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
 
-    // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
-    for (const tag of attribute["x-typia-metaTags"] ?? []) {
-        // RANGE
-        if (tag.kind === "minLength") output.minLength = tag.value;
-        else if (tag.kind === "maxLength") output.maxLength = tag.value;
-        // FORMAT AND PATTERN
-        else if (tag.kind === "format") output.format = emendFormat(tag.value);
-        else if (tag.kind === "pattern") output.pattern = tag.value;
-    }
+        // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
+        for (const tag of attribute["x-typia-metaTags"] ?? []) {
+            // RANGE
+            if (tag.kind === "minLength") output.minLength = tag.value;
+            else if (tag.kind === "maxLength") output.maxLength = tag.value;
+            // FORMAT AND PATTERN
+            else if (tag.kind === "format")
+                output.format = emendFormat(tag.value);
+            else if (tag.kind === "pattern") output.pattern = tag.value;
+        }
 
-    // DEFAULT CONFIGURATION
-    output.default = application_default_string(meta)(attribute)(output);
+        // DEFAULT CONFIGURATION
+        output.default = application_default_string(meta)(attribute)(output);
 
-    // RETURNS
-    return output;
-};
+        // RETURNS
+        return output;
+    };
 
 const emendFormat = (tag: IMetadataTag.IFormat["value"]) =>
     tag === "datetime" ? "date-time" : tag;

package/src/programmers/internal/application_templates.ts

@@ -13,7 +13,6 @@ export const application_templates =
         // CONSTRUCT PATTERN
         const output: IJsonSchema.IString = {
             type: "string",
-            nullable: meta.nullable,
             ...attribute,
         };
         output.pattern = metadata_to_pattern(true)(meta);

package/src/programmers/internal/application_tuple.ts

@@ -12,20 +12,16 @@ export const application_tuple =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (items: Array<Metadata>) =>
-    (props: {
-        nullable: boolean;
-        attribute: IJsonSchema.IAttribute;
-    }): IJsonSchema.ITuple => ({
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.ITuple => ({
         type: "array",
         items: items.map((meta, i) =>
             application_schema(options)(false)(components)(meta.rest ?? meta)({
-                ...props.attribute,
+                ...attribute,
                 "x-typia-rest":
                     i === items.length - 1 ? meta.rest !== null : undefined,
                 "x-typia-required": meta.required,
                 "x-typia-optional": meta.optional,
             }),
         ),
-        nullable: props.nullable,
-        ...props.attribute,
+        ...attribute,
     });

package/src/programmers/internal/check_array.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
@@ -15,16 +15,17 @@ 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(input),
+        expression: ExpressionFactory.isArray(tsc)(input),
         tags: [
-            ...check_array_length(metaTags)(
-                IdentifierFactory.access(input)("length"),
+            ...check_array_length(tsc)(metaTags)(
+                IdentifierFactory.access(tsc)(input)("length"),
             ),
-            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
+            ...check_custom(tsc)("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 ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
@@ -6,24 +6,24 @@ import { IMetadataTag } from "../../metadata/IMetadataTag";
  * @internal
  */
 export const check_array_length =
-    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
+    (tsc: typeof ts) => (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
         metaTags
             .map((tag) => ({
                 tag,
                 expression:
                     tag.kind === "items"
-                        ? ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(tag.value),
+                        ? tsc.factory.createStrictEquality(
+                              tsc.factory.createNumericLiteral(tag.value),
                               input,
                           )
                         : tag.kind === "minItems"
-                        ? ts.factory.createLessThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
+                        ? tsc.factory.createLessThanEquals(
+                              tsc.factory.createNumericLiteral(tag.value),
                               input,
                           )
                         : tag.kind === "maxItems"
-                        ? ts.factory.createGreaterThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
+                        ? tsc.factory.createGreaterThanEquals(
+                              tsc.factory.createNumericLiteral(tag.value),
                               input,
                           )
                         : null!,

package/src/programmers/internal/check_bigint.ts

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

package/src/programmers/internal/check_custom.ts

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