typia 6.0.0-dev.20240122 → 6.0.0

package/src/factories/MetadataCommentTagFactory.ts

@@ -5,6 +5,7 @@ import { Metadata } from "../schemas/metadata/Metadata";
 
 import { Writable } from "../typings/Writable";
 
+import { FormatCheatSheet } from "../tags/internal/FormatCheatSheet";
 import { MetadataFactory } from "./MetadataFactory";
 import { MetadataTypeTagFactory } from "./MetadataTypeTagFactory";
 
@@ -116,8 +117,9 @@ type TagRecord = {
   [P in Target]?: NotDeterminedTypeTag[];
 };
 type Target = "bigint" | "number" | "string" | "array";
-type NotDeterminedTypeTag = Omit<IMetadataTypeTag, "validate"> & {
+type NotDeterminedTypeTag = Omit<IMetadataTypeTag, "validate" | "schema"> & {
   validate: string | null;
+  schema: object | undefined;
 };
 
 const PARSER: Record<
@@ -138,6 +140,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minItems: parse_integer(report)(true)(Value),
+        },
       },
       {
         name: `MaxItems<${Value}>`,
@@ -146,6 +151,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxItems: parse_integer(report)(true)(Value),
+        },
       },
     ],
   }),
@@ -158,6 +166,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minItems: parse_integer(report)(true)(Value),
+        },
       },
     ],
   }),
@@ -170,6 +181,9 @@ const PARSER: Record<
         value: parse_integer(report)(true)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxItems: parse_integer(report)(true)(Value),
+        },
       },
     ],
   }),
@@ -202,15 +216,16 @@ const PARSER: Record<
             Value === "int32"
               ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
               : Value === "uint32"
-              ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
-              : Value === "int64"
-              ? `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`
-              : Value === "uint64"
-              ? `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`
-              : Value === "float"
-              ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
-              : `true`,
+                ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
+                : Value === "int64"
+                  ? `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`
+                  : Value === "uint64"
+                    ? `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`
+                    : Value === "float"
+                      ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
+                      : `true`,
           exclusive: true,
+          schema: undefined,
         },
       ],
       bigint:
@@ -223,6 +238,7 @@ const PARSER: Record<
                 value: Value,
                 validate: Value === "int64" ? "true" : "BigInt(0) <= $input",
                 exclusive: true,
+                schema: undefined,
               },
             ]
           : [],
@@ -237,6 +253,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} <= $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: {
+          minimum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -250,6 +269,7 @@ const PARSER: Record<
         })(),
         validate: `${Value} <= $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: undefined,
       },
     ],
   }),
@@ -262,6 +282,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input <= ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: {
+          maximum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -275,6 +298,7 @@ const PARSER: Record<
         })(),
         validate: `$input <= ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: undefined,
       },
     ],
   }),
@@ -287,6 +311,10 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} < $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: {
+          exclusiveMinimum: true,
+          minimum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -300,6 +328,7 @@ const PARSER: Record<
         })(),
         validate: `${Value} < $input`,
         exclusive: ["minimum", "exclusiveMinimum"],
+        schema: undefined,
       },
     ],
   }),
@@ -312,6 +341,10 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input < ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: {
+          exclusiveMaximum: true,
+          maximum: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -325,6 +358,7 @@ const PARSER: Record<
         })(),
         validate: `$input < ${Value}`,
         exclusive: ["maximum", "exclusiveMaximum"],
+        schema: undefined,
       },
     ],
   }),
@@ -337,6 +371,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input % ${Value} === 0`,
         exclusive: true,
+        schema: {
+          multipleOf: parse_number(report)(Value),
+        },
       },
     ],
     bigint: [
@@ -350,6 +387,7 @@ const PARSER: Record<
         })(),
         validate: `$input % ${Value}n === 0n`,
         exclusive: true,
+        schema: undefined,
       },
     ],
   }),
@@ -369,6 +407,9 @@ const PARSER: Record<
           value: matched[0],
           validate: matched[1],
           exclusive: true,
+          schema: {
+            format: matched[0],
+          },
         },
       ],
     };
@@ -382,6 +423,9 @@ const PARSER: Record<
         value: Value,
         validate: `RegExp(/${Value}/).test($input)`,
         exclusive: ["format"],
+        schema: {
+          pattern: Value,
+        },
       },
     ],
   }),
@@ -394,6 +438,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minLength: parse_number(report)(Value),
+        },
       },
       {
         name: `MaxLength<${Value}>`,
@@ -402,6 +449,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxLength: parse_number(report)(Value),
+        },
       },
     ],
   }),
@@ -414,6 +464,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `${Value} <= $input.length`,
         exclusive: true,
+        schema: {
+          minLength: parse_number(report)(Value),
+        },
       },
     ],
   }),
@@ -426,6 +479,9 @@ const PARSER: Record<
         value: parse_number(report)(Value),
         validate: `$input.length <= ${Value}`,
         exclusive: true,
+        schema: {
+          maxLength: parse_number(report)(Value),
+        },
       },
     ],
   }),
@@ -451,151 +507,10 @@ const parse_integer =
     return value;
   };
 
-type IMetadataCommentTag =
-  // NUMBER
-  | IMetadataCommentTag.IType
-  | IMetadataCommentTag.IMinimum
-  | IMetadataCommentTag.IMaximum
-  | IMetadataCommentTag.IExclusiveMinimum
-  | IMetadataCommentTag.IExclusiveMaximum
-  | IMetadataCommentTag.IMultipleOf
-  | IMetadataCommentTag.IStep
-  // STRING
-  | IMetadataCommentTag.IFormat
-  | IMetadataCommentTag.IPattern
-  | IMetadataCommentTag.ILength
-  | IMetadataCommentTag.IMinLength
-  | IMetadataCommentTag.IMaxLength
-  // ARRAY
-  | IMetadataCommentTag.IItems
-  | IMetadataCommentTag.IMinItems
-  | IMetadataCommentTag.IMaxItems;
-
-namespace IMetadataCommentTag {
-  /* -----------------------------------------------------------
-        NUMBER
-    ----------------------------------------------------------- */
-  export interface IType {
-    kind: "type";
-    value: "int" | "uint" | "int32" | "uint32" | "int64" | "uint64" | "float";
-  }
-
-  export interface IMinimum {
-    kind: "minimum";
-    value: number;
-  }
-
-  export interface IMaximum {
-    kind: "maximum";
-    value: number;
-  }
-
-  export interface IExclusiveMinimum {
-    kind: "exclusiveMinimum";
-    value: number;
-  }
-
-  export interface IExclusiveMaximum {
-    kind: "exclusiveMaximum";
-    value: number;
-  }
-
-  export interface IMultipleOf {
-    kind: "multipleOf";
-    value: number;
-  }
-
-  export interface IStep {
-    kind: "step";
-    value: number;
-  }
-
-  /* -----------------------------------------------------------
-        STRING
-    ----------------------------------------------------------- */
-  export interface IFormat {
-    kind: "format";
-    value: "uuid" | "email" | "url" | "ipv4" | "ipv6" | "date" | "date-time";
-  }
-
-  export interface IPattern {
-    kind: "pattern";
-    value: string;
-  }
-
-  export interface ILength {
-    kind: "length";
-    value: number;
-  }
-
-  export interface IMinLength {
-    kind: "minLength";
-    value: number;
-  }
-
-  export interface IMaxLength {
-    kind: "maxLength";
-    value: number;
-  }
-
-  /* -----------------------------------------------------------
-        ARRAY   
-    ----------------------------------------------------------- */
-  export interface IItems {
-    kind: "items";
-    value: number;
-  }
-
-  export interface IMinItems {
-    kind: "minItems";
-    value: number;
-  }
-
-  export interface IMaxItems {
-    kind: "maxItems";
-    value: number;
-  }
-}
-
-const FORMATS: Map<string, [IMetadataCommentTag.IFormat["value"], string]> =
-  new Map([
-    [
-      "email",
-      [
-        "email",
-        `/^(([^<>()[\\]\\.,;:\\s@\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\"]+)*)|(\\".+\\"))@(([^<>()[\\]\\.,;:\\s@\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\"]{2,})$/i.test($input)`,
-      ],
-    ],
-    [
-      "uuid",
-      [
-        "uuid",
-        `/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i.test($input)`,
-      ],
-    ],
-    [
-      "ipv4",
-      [
-        "ipv4",
-        `/^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test($input)`,
-      ],
-    ],
-    [
-      "ipv6",
-      [
-        "ipv6",
-        `/^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/.test($input)`,
-      ],
-    ],
-    [
-      "url",
-      [
-        "url",
-        `/^[a-zA-Z0-9]+:\\/\\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test($input)`,
-      ],
-    ],
-    ["date", ["date", `/^(\\d{4})-(\\d{2})-(\\d{2})$/.test($input)`]],
-    ["datetime", ["date-time", `!isNaN(new Date($input).getTime())`]],
-    ["date-time", ["date-time", `!isNaN(new Date($input).getTime())`]],
-    ["dateTime", ["date-time", `!isNaN(new Date($input).getTime())`]],
-  ]);
+const FORMATS: Map<string, [string, string]> = new Map([
+  ...Object.entries(FormatCheatSheet).map(
+    ([key, value]) => [key, [key, value]] as any,
+  ),
+  ["datetime", ["date-time", `!isNaN(new Date($input).getTime())`]],
+  ["dateTime", ["date-time", `!isNaN(new Date($input).getTime())`]],
+]);

package/src/factories/MetadataFactory.ts

@@ -80,7 +80,12 @@ export namespace MetadataFactory {
     const meta: Metadata = Metadata.initialize();
     meta.constants.push(
       MetadataConstant.from({
-        values: [value],
+        values: [
+          {
+            value,
+            tags: undefined,
+          },
+        ],
         type: "string",
       }),
     );

package/src/factories/MetadataTypeTagFactory.ts

@@ -4,6 +4,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../schemas/metadata/MetadataProperty";
 
 import { MetadataFactory } from "./MetadataFactory";
+import { MetadataTypeTagSchemaFactory } from "./MetadataTypeTagSchemaFactory";
 
 export namespace MetadataTypeTagFactory {
   export const analyze =
@@ -83,6 +84,7 @@ export namespace MetadataTypeTagFactory {
             value: tag.value,
             validate: tag.validate[type]!,
             exclusive: tag.exclusive,
+            schema: tag.schema,
           });
       validate(report)(type)(output);
 
@@ -141,11 +143,11 @@ export namespace MetadataTypeTagFactory {
           value.constants[0]!.values.length !== value.size() ||
           value.constants[0]!.values.some(
             (v) =>
-              v !== "boolean" &&
-              v !== "bigint" &&
-              v !== "number" &&
-              v !== "string" &&
-              v !== "array",
+              v.value !== "boolean" &&
+              v.value !== "bigint" &&
+              v.value !== "number" &&
+              v.value !== "string" &&
+              v.value !== "array",
           ))
       )
         return report(key)(
@@ -231,12 +233,13 @@ export namespace MetadataTypeTagFactory {
           (p) => p.key.getSoleLiteral() === key,
         );
 
-      const target = find("target")!.value.constants[0]!
-        .values as ITypeTag["target"];
-      const kind: string = find("kind")!.value.constants[0]!
-        .values[0] as string;
+      const target = find("target")!.value.constants[0]!.values.map(
+        (v) => v.value,
+      ) as ITypeTag["target"];
+      const kind: string = find("kind")!.value.constants[0]!.values[0]!
+        .value as string;
       const value: boolean | bigint | number | string | undefined =
-        find("value")?.value.constants[0]?.values[0];
+        find("value")?.value.constants[0]?.values[0]!.value;
       const exclusive: string[] | boolean | null = get_exclusive(report)(
         "exclusive",
       )(find("exclusive")?.value);
@@ -247,16 +250,34 @@ export namespace MetadataTypeTagFactory {
         if (!validate || validate.size() === 0) return {};
         else if (validate.constants.length)
           return Object.fromEntries(
-            target.map((t) => [t, validate.constants[0]!.values[0] as string]),
+            target.map((t) => [
+              t,
+              validate.constants[0]!.values[0]!.value as string,
+            ]),
           );
         return Object.fromEntries(
           validate.objects[0]!.properties.map((p) => [
             p.key.getSoleLiteral()!,
-            p.value.constants[0]!.values[0]! as string,
+            p.value.constants[0]!.values[0]!.value as string,
           ]),
         );
       })();
-
+      const schema: object | undefined = (() => {
+        const p: Metadata | undefined = find("schema")?.value;
+        if (p === undefined) return undefined;
+        else if (p.size() === 0 && p.isRequired() === false) return undefined;
+        else if (
+          p.size() === 1 &&
+          p.nullable === false &&
+          p.isRequired() === true &&
+          p.any === false
+        )
+          return MetadataTypeTagSchemaFactory.object((msg) =>
+            report("schema")(msg),
+          )(p.objects[0]!);
+        report("schema")("must be an object type");
+        return undefined;
+      })();
       return {
         name: obj.name,
         target,
@@ -264,6 +285,7 @@ export namespace MetadataTypeTagFactory {
         value,
         validate,
         exclusive: exclusive ?? false,
+        schema,
       };
     };
 
@@ -278,7 +300,7 @@ export namespace MetadataTypeTagFactory {
         value.constants[0]!.type === "boolean" &&
         value.constants[0]!.values.length === 1
       )
-        return value.constants[0]!.values[0]! as boolean;
+        return value.constants[0]!.values[0]!.value as boolean;
       else if (
         value.size() === 1 &&
         value.tuples.length === 1 &&
@@ -291,7 +313,7 @@ export namespace MetadataTypeTagFactory {
         )
       )
         return value.tuples[0]!.type.elements.map(
-          (elem) => elem.constants[0]!.values[0]! as string,
+          (elem) => elem.constants[0]!.values[0]!.value as string,
         );
       report(key)(
         "must a boolean literal type or a tuple of string literal types.",
@@ -307,6 +329,7 @@ interface ITypeTag {
   value?: undefined | boolean | bigint | number | string;
   validate: Record<string, string>;
   exclusive: boolean | string[];
+  schema?: undefined | any;
 }
 
 const ESSENTIAL_FIELDS = ["target", "kind", "value"];

package/src/factories/MetadataTypeTagSchemaFactory.ts

@@ -0,0 +1,59 @@
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+export namespace MetadataTypeTagSchemaFactory {
+  export const object =
+    (report: (msg: string) => false) =>
+    (obj: MetadataObject): object | undefined => {
+      if (obj.recursive) {
+        report(`${obj.name} has recursive type`);
+        return undefined;
+      }
+      const output: any = {};
+      for (const p of obj.properties) {
+        const key: string | null = p.key.getSoleLiteral()!;
+        if (key === null) {
+          report(`${obj.name} has non-literal key type: ${p.key.getName()}`);
+          continue;
+        }
+        output[key] = iterate(report)({ object: obj, key })(p.value);
+      }
+      return output;
+    };
+
+  const iterate =
+    (report: (msg: string) => false) =>
+    (parent: { object: MetadataObject; key: string }) =>
+    (meta: Metadata): any => {
+      if (
+        meta.any ||
+        meta.atomics.length ||
+        meta.arrays.length ||
+        meta.natives.length ||
+        meta.functional
+      )
+        report(`${parent.object.name}.${parent.key} has non-literal type`);
+      else if (meta.size() > 1)
+        report(`${parent.object.name}.${parent.key} has union type`);
+      else if (meta.size() === 0)
+        if (meta.nullable) return null;
+        else if (meta.isRequired() === true)
+          report(`${parent.object.name}.${parent.key} has non-literal type`);
+        else return undefined;
+      else if (meta.constants.length)
+        return meta.constants[0]!.values[0]!.value;
+      else if (meta.tuples.length) {
+        const tuple = meta.tuples[0]!;
+        if (tuple.type.isRest())
+          report(`${parent.object.name}.${parent.key} has rest tuple type`);
+        else if (tuple.type.recursive)
+          report(
+            `${parent.object.name}.${parent.key} has recursive tuple type`,
+          );
+        else if (tuple.type.elements.some((e) => e.required === false))
+          report(`${parent.object.name}.${parent.key} has optional tuple type`);
+        return tuple.type.elements.map(iterate(report)(parent));
+      } else if (meta.objects.length) return object(report)(meta.objects[0]!);
+      else report(`${parent.object.name}.${parent.key} has non-literal type`);
+    };
+}

package/src/factories/ProtobufFactory.ts

@@ -109,7 +109,15 @@ export namespace ProtobufFactory {
     )
       noSupport("optional type in array");
     // UNION IN ARRAY
-    if (meta.arrays.length && meta.arrays.some((a) => a.type.value.size() > 1))
+    if (
+      meta.arrays.length &&
+      meta.arrays.some(
+        (a) =>
+          a.type.value.size() > 1 &&
+          a.type.value.constants.length !== 1 &&
+          a.type.value.constants[0]?.values.length !== a.type.value.size(),
+      )
+    )
       noSupport("union type in array");
     // DO DYNAMIC OBJECT IN ARRAY
     if (

package/src/factories/TypeFactory.ts

@@ -11,10 +11,10 @@ export namespace TypeFactory {
     return ts.isFunctionLike(node)
       ? node
       : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
-      ? ts.isFunctionLike(node.initializer)
-        ? node.initializer
-        : null
-      : null;
+        ? ts.isFunctionLike(node.initializer)
+          ? node.initializer
+          : null
+        : null;
   };
 
   export const getReturnType =
@@ -103,16 +103,16 @@ export namespace TypeFactory {
       type === "void"
         ? ts.SyntaxKind.VoidKeyword
         : type === "any"
-        ? ts.SyntaxKind.AnyKeyword
-        : type === "unknown"
-        ? ts.SyntaxKind.UnknownKeyword
-        : type === "boolean"
-        ? ts.SyntaxKind.BooleanKeyword
-        : type === "number"
-        ? ts.SyntaxKind.NumberKeyword
-        : type === "bigint"
-        ? ts.SyntaxKind.BigIntKeyword
-        : ts.SyntaxKind.StringKeyword,
+          ? ts.SyntaxKind.AnyKeyword
+          : type === "unknown"
+            ? ts.SyntaxKind.UnknownKeyword
+            : type === "boolean"
+              ? ts.SyntaxKind.BooleanKeyword
+              : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                  ? ts.SyntaxKind.BigIntKeyword
+                  : ts.SyntaxKind.StringKeyword,
     );
   };
 }

package/src/factories/internal/metadata/MetadataHelper.ts

@@ -1,5 +1,6 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
 
 export namespace MetadataHelper {
   export const literal_to_metadata = (key: string): Metadata => {
@@ -7,7 +8,12 @@ export namespace MetadataHelper {
     metadata.constants.push(
       MetadataConstant.create({
         type: "string",
-        values: [key],
+        values: [
+          MetadataConstantValue.create({
+            value: key,
+            tags: undefined,
+          }),
+        ],
       }),
     );
     return metadata;