typia 5.0.0-dev.20230824 → 5.0.0-dev.20230827

package/src/programmers/internal/application_array.ts

@@ -1,5 +1,6 @@
 import { IJsonComponents } from "../../schemas/json/IJsonComponents";
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 
 import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
@@ -12,20 +13,41 @@ export const application_array =
     (options: JsonApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (array: MetadataArray) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray => {
-        // SCHEMA
-        const schema: IJsonSchema.IArray = {
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray[] => {
+        // BASE SCHEMA
+        const items: IJsonSchema = application_schema(options)(false)(
+            components,
+        )(array.type.value)(attribute);
+        const base: IJsonSchema.IArray = {
             ...attribute,
             type: "array",
-            items: application_schema(options)(false)(components)(
-                array.type.value,
-            )(attribute),
+            items: null!,
         };
+        const out = (schema: IJsonSchema.IArray) => {
+            schema.items = items;
+            return schema;
+        };
+        if (array.tags.length === 0) return [out(base)];
 
-        // COMMENT TAGS
-        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;
+        // CONSIDER TYPE TAGS
+        const union: IJsonSchema.IArray[] = array.tags.map(
+            (row) => application_array_tags({ ...base })(row)!,
+        );
+        const map: Map<string, IJsonSchema.IArray> = new Map(
+            union.map((u) => [JSON.stringify(u), u]),
+        );
+        return [...map.values()].map((s) => out(s));
+    };
 
+const application_array_tags =
+    (schema: IJsonSchema.IArray) =>
+    (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
+        for (const tag of row
+            .slice()
+            .sort((a, b) => a.kind.localeCompare(b.kind)))
+            if (tag.kind === "minItems" && typeof tag.value === "number")
+                schema.minItems = tag.value;
+            else if (tag.kind === "maxItems" && typeof tag.value === "number")
+                schema.maxItems = tag.value;
         return schema;
     };

package/src/programmers/internal/application_number.ts

@@ -1,81 +1,87 @@
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
 import { IJsonSchema } from "../../module";
 import { application_default } from "./application_default";
 
+type Schema = IJsonSchema.INumber | IJsonSchema.IInteger;
+
 /**
  * @internal
  */
-export const application_number = (
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.INumber | IJsonSchema.IInteger => {
-    const output: IJsonSchema.INumber | IJsonSchema.IInteger = {
-        ...attribute,
-        type: "number" as "number" | "integer",
+export const application_number =
+    (atomic: MetadataAtomic) =>
+    (attribute: IJsonSchema.IAttribute): Array<Schema> => {
+        // BASE CONFIGURATION
+        const base: Schema = {
+            ...attribute,
+            type: "number",
+        };
+        const out = (schema: Schema) => {
+            schema.default = application_default(attribute)((str) => {
+                const value: number = Number(str);
+                const conditions: boolean[] = [!Number.isNaN(value)];
+                if (schema.minimum !== undefined)
+                    if (schema.exclusiveMinimum === true)
+                        conditions.push(value > schema.minimum);
+                    else conditions.push(value >= schema.minimum);
+                if (schema.maximum !== undefined)
+                    if (schema.exclusiveMaximum === true)
+                        conditions.push(value < schema.maximum);
+                    else conditions.push(value <= schema.maximum);
+                if (schema.multipleOf !== undefined)
+                    conditions.push(value % schema.multipleOf === 0);
+                return conditions.every((cond) => cond);
+            })((str) => Number(str));
+            return schema;
+        };
+        if (atomic.tags.length === 0) return [out(base)];
+
+        // CONSIDER TYPE TAGS
+        const union: Schema[] = atomic.tags.map(
+            (row) => application_number_tags({ ...base })(row)!,
+        );
+        const map: Map<string, Schema> = new Map(
+            union.map((u) => [JSON.stringify(u), u]),
+        );
+        return [...map.values()].map((s) => out(s));
     };
-    for (const tag of attribute["x-typia-metaTags"] ?? []) {
-        // CHECK TYPE
-        if (tag.kind === "type") {
-            if (
-                tag.value === "int" ||
-                tag.value === "uint" ||
-                tag.value === "int32" ||
-                tag.value === "uint32" ||
-                tag.value === "int64" ||
-                tag.value === "uint64"
-            )
-                output.type = "integer";
-        }
-        // RANGE TAG
-        else if (tag.kind === "minimum") output.minimum = tag.value;
-        else if (tag.kind === "maximum") output.maximum = tag.value;
-        else if (tag.kind === "exclusiveMinimum") {
-            output.minimum = tag.value;
-            output.exclusiveMinimum = true;
-        } else if (tag.kind === "exclusiveMaximum") {
-            output.maximum = tag.value;
-            output.exclusiveMaximum = true;
-        }
-        // MULTIPLE-OF
-        else if (tag.kind === "multipleOf") output.multipleOf = tag.value;
-    }
 
-    // WHEN UNSIGNED INT
-    if (
-        output.type === "integer" &&
-        (attribute["x-typia-metaTags"] ?? []).find(
-            (tag) =>
+const application_number_tags =
+    (schema: Schema) =>
+    (row: IMetadataTypeTag[]): Schema => {
+        for (const tag of row
+            .slice()
+            .sort((a, b) => a.kind.localeCompare(b.kind))) {
+            if (
                 tag.kind === "type" &&
-                (tag.value === "uint" ||
+                (tag.value === "int32" ||
                     tag.value === "uint32" ||
-                    tag.value === "uint64"),
-        )
-    )
-        if (
-            output.minimum === undefined ||
-            (output.exclusiveMaximum !== true && output.minimum < 0)
-        )
-            output.minimum = 0;
-        else if (output.exclusiveMinimum === true && output.minimum < -1) {
-            output.maximum = 0;
-            delete output.exclusiveMinimum;
+                    tag.value === "int64" ||
+                    tag.value === "uint64")
+            )
+                schema.type = "integer";
+            else if (tag.kind === "minimum" && typeof tag.value === "number")
+                schema.minimum = tag.value;
+            else if (tag.kind === "maximum" && typeof tag.value === "number")
+                schema.maximum = tag.value;
+            else if (
+                tag.kind === "exclusiveMinimum" &&
+                typeof tag.value === "number"
+            ) {
+                schema.minimum = tag.value;
+                schema.exclusiveMinimum = true;
+            } else if (
+                tag.kind === "exclusiveMaximum" &&
+                typeof tag.value === "number"
+            ) {
+                schema.maximum = tag.value;
+                schema.exclusiveMaximum = true;
+            } else if (
+                tag.kind === "multipleOf" &&
+                typeof tag.value === "number"
+            )
+                schema.multipleOf = tag.value;
         }
-
-    // DEFAULT CONFIGURATION
-    output.default = application_default(attribute)((str) => {
-        const value: number = Number(str);
-        const conditions: boolean[] = [!Number.isNaN(value)];
-        if (output.minimum !== undefined)
-            if (output.exclusiveMinimum === true)
-                conditions.push(value > output.minimum);
-            else conditions.push(value >= output.minimum);
-        if (output.maximum !== undefined)
-            if (output.exclusiveMaximum === true)
-                conditions.push(value < output.maximum);
-            else conditions.push(value <= output.maximum);
-        if (output.multipleOf !== undefined)
-            conditions.push(value % output.multipleOf === 0);
-        return conditions.every((cond) => cond);
-    })((str) => Number(str));
-
-    // RETURNS
-    return output;
-};
+        return schema;
+    };

package/src/programmers/internal/application_object.ts

@@ -69,9 +69,6 @@ export const application_object =
                         : undefined;
                 })(),
                 description: property.description ?? undefined,
-                "x-typia-metaTags": property.tags.length
-                    ? property.tags
-                    : undefined,
                 "x-typia-jsDocTags": property.jsDocTags.length
                     ? property.jsDocTags
                     : undefined,

package/src/programmers/internal/application_schema.ts

@@ -1,6 +1,7 @@
 import { IJsonComponents } from "../../schemas/json/IJsonComponents";
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
 import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
 import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
@@ -78,19 +79,20 @@ export const application_schema =
             else insert(application_constant(constant)(attribute));
         for (const a of meta.atomics)
             if (a.type === "bigint") throw new Error(NO_BIGINT);
-            else if (AtomicPredicator.atomic(meta)(a.type) === false) continue;
-            else
-                insert(
-                    a.type === "string"
-                        ? application_string(meta)(attribute)
-                        : a.type === "boolean"
-                        ? application_boolean(attribute)
-                        : application_number(attribute),
+            else if (a.type === "boolean")
+                insert(application_boolean(attribute));
+            else if (a.type === "number")
+                application_number(a)(attribute).forEach((s) => insert(s));
+            else if (a.type === "string")
+                application_string(meta)(a)(attribute).forEach((s) =>
+                    insert(s),
                 );
 
         // ARRAY
         for (const array of meta.arrays)
-            insert(application_array(options)(components)(array)(attribute));
+            application_array(options)(components)(array)(attribute).forEach(
+                (s) => insert(s),
+            );
 
         // TUPLE
         for (const tuple of meta.tuples)
@@ -98,15 +100,31 @@ export const application_schema =
 
         // NATIVES
         for (const native of meta.natives)
-            if (AtomicPredicator.native(native))
-                insert(
-                    native === "String"
-                        ? application_string(meta)(attribute)
-                        : native === "Boolean"
-                        ? application_boolean(attribute)
-                        : application_number(attribute),
-                );
-            else
+            if (AtomicPredicator.native(native)) {
+                const type: string = native.toLowerCase();
+                if (meta.atomics.some((a) => a.type === type)) continue;
+                else if (type === "bigint") throw new Error(NO_BIGINT);
+                else if (type === "boolean")
+                    insert(application_boolean(attribute));
+                else if (type === "number")
+                    insert(
+                        application_number(
+                            MetadataAtomic.create({
+                                type: "number",
+                                tags: [],
+                            }),
+                        )(attribute)[0]!,
+                    );
+                else if (type === "string")
+                    insert(
+                        application_string(meta)(
+                            MetadataAtomic.create({
+                                type: "string",
+                                tags: [],
+                            }),
+                        )(attribute)[0]!,
+                    );
+            } else
                 insert(
                     application_native(options)(components)(native)({
                         nullable: meta.nullable,

package/src/programmers/internal/application_string.ts

@@ -1,6 +1,7 @@
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
 import { application_default_string } from "./application_default_string";
 
@@ -9,36 +10,41 @@ import { application_default_string } from "./application_default_string";
  */
 export const application_string =
     (meta: Metadata) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema.IString => {
-        const output: IJsonSchema.IString = {
+    (atomic: MetadataAtomic) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IString[] => {
+        // DEFAULT CONFIGURATION
+        const base: IJsonSchema.IString = {
             ...attribute,
             type: "string",
         };
+        const out = (schema: IJsonSchema.IString) => {
+            schema.default = application_default_string(meta)(attribute)(base);
+            return schema;
+        };
+        if (atomic.tags.length === 0) return [out(base)];
 
-        // FORMAT TAG OF METADATA
-        const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
-            (tag) => tag.name === "format",
+        // CONSIDER TYPE TAGS
+        const union: IJsonSchema.IString[] = atomic.tags.map(
+            (row) => application_string_tags({ ...base })(row)!,
         );
-        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;
-        }
-
-        // DEFAULT CONFIGURATION
-        output.default = application_default_string(meta)(attribute)(output);
-
-        // RETURNS
-        return output;
+        const map: Map<string, IJsonSchema.IString> = new Map(
+            union.map((u) => [JSON.stringify(u), u]),
+        );
+        return [...map.values()].map((s) => out(s));
     };
 
-const emendFormat = (tag: IMetadataCommentTag.IFormat["value"]) =>
-    tag === "datetime" ? "date-time" : tag;
+const application_string_tags =
+    (schema: IJsonSchema.IString) =>
+    (row: IMetadataTypeTag[]): IJsonSchema.IString | null => {
+        for (const tag of row
+            .slice()
+            .sort((a, b) => a.kind.localeCompare(b.kind)))
+            if (tag.kind === "minLength" && typeof tag.value === "number")
+                schema.minLength = tag.value;
+            else if (tag.kind === "maxLength" && typeof tag.value === "number")
+                schema.maxLength = tag.value;
+            else if (tag.kind === "format" && typeof tag.value === "string")
+                schema.format = tag.value;
+            else if (tag.kind === "pattern") schema.pattern = tag.value;
+        return schema;
+    };

package/src/programmers/internal/check_array_length.ts

@@ -1,35 +1,41 @@
 import ts from "typescript";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 /**
  * @internal
  */
 export const check_array_length =
-    (metaTags: IMetadataCommentTag[]) => (input: ts.Expression) =>
-        metaTags
-            .map((tag) => ({
-                tag,
-                expression:
-                    tag.kind === "items"
-                        ? ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "minItems"
-                        ? ts.factory.createLessThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "maxItems"
-                        ? ts.factory.createGreaterThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : null!,
-            }))
-            .filter((tuple) => tuple.expression !== null)
-            .map(({ tag, expression }) => ({
-                expected: `Array.length (@${tag.kind} ${tag.value})`,
-                expression,
-            }));
+    (project: IProject) =>
+    (array: MetadataArray) =>
+    (input: ts.Expression): ICheckEntry => {
+        const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
+            project,
+        )(array.tags)(input);
+
+        return {
+            expected: array.getName(),
+            expression: null,
+            conditions,
+        };
+    };
+
+const check_string_type_tags =
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][]) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        matrix.map((row) =>
+            row.map((tag) => ({
+                expected: `Array<> & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_bigint.ts

@@ -2,8 +2,7 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -14,125 +13,33 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
  */
 export const check_bigint =
     (project: IProject) =>
-    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
+    (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataCommentTag, ts.Expression][] = [];
-        for (const tag of metaTags) {
-            if (tag.kind === "type" && tag.value === "uint64")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ExpressionFactory.bigint(0),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "multipleOf")
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ExpressionFactory.bigint(0),
-                        ts.factory.createModulo(
-                            input,
-                            ExpressionFactory.bigint(tag.value),
-                        ),
-                    ),
-                ]);
-            else if (tag.kind === "step") {
-                const modulo = ts.factory.createModulo(
-                    input,
-                    ExpressionFactory.bigint(tag.value),
-                );
-                const minimum =
-                    (metaTags.find(
-                        (tag) =>
-                            tag.kind === "minimum" ||
-                            tag.kind === "exclusiveMinimum",
-                    )?.value as number | undefined) ?? undefined;
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ExpressionFactory.bigint(0),
-                        minimum !== undefined
-                            ? ts.factory.createSubtract(
-                                  modulo,
-                                  ExpressionFactory.bigint(minimum),
-                              )
-                            : modulo,
-                    ),
-                ]);
-            } else if (tag.kind === "minimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "maximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThanEquals(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMinimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThan(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMaximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThan(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-        }
-        return {
-            expression: is_bigint(project)(matrix)(input),
-            tags: matrix.length
-                ? []
-                : entries.map(([tag, expression]) => ({
-                      expected: `bigint (@${tag.kind} ${tag.value})`,
-                      expression,
-                  })),
-        };
-    };
+        const conditions: ICheckEntry.ICondition[][] =
+            check_bigint_type_tags(project)(atomic)(input);
 
-const is_bigint =
-    (project: IProject) =>
-    (matrix: IMetadataTypeTag[][]) =>
-    (input: ts.Expression) => {
-        // BASIC TYPEOF EXPRESSION
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
+        return {
+            expected: atomic.getName(),
+            expression: ts.factory.createStrictEquality(
                 ts.factory.createStringLiteral("bigint"),
                 ts.factory.createTypeOfExpression(input),
             ),
-        ];
-
-        // ADJUST TYPED TAGS
-        if (matrix.length) {
-            const logic: ts.Expression = matrix
-                .map((row) =>
-                    row
-                        .map((tag) =>
-                            ExpressionFactory.transpile(project.context)(
-                                tag.validate,
-                            )(input),
-                        )
-                        .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                )
-                .reduce((a, b) => ts.factory.createLogicalOr(a, b));
-            conditions.push(logic);
-        }
-
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+            conditions,
+        };
     };
+
+/**
+ * @internal
+ */
+const check_bigint_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) =>
+            row.map((tag) => ({
+                expected: `bigint & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_dynamic_properties.ts

@@ -111,8 +111,7 @@ const check_dynamic_property =
             );
 
         // GATHER CONDITIONS
-        if (props.equals === true && regular.length)
-            add(is_regular_property(regular), props.positive);
+        if (regular.length) add(is_regular_property(regular), props.positive);
         statements.push(
             StatementFactory.constant(
                 "value",