typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/internal/application_v31_object.ts

@@ -0,0 +1,141 @@
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { application_v31_schema } from "./application_v31_schema";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const application_v31_object =
+  (components: OpenApi.IComponents) =>
+  (
+    obj: MetadataObject,
+  ): OpenApi.IJsonSchema.IReference | OpenApi.IJsonSchema.IObject => {
+    const $ref: string = `#/components/schemas/${obj.name}`;
+    if (components.schemas?.[obj.name] !== undefined) return { $ref };
+
+    const object: OpenApiV3.IJsonSchema = {};
+    components.schemas ??= {};
+    components.schemas[obj.name] = object;
+    Object.assign(object, create_object_schema(components)(obj));
+    return { $ref };
+  };
+
+/**
+ * @internal
+ */
+const create_object_schema =
+  (components: OpenApi.IComponents) =>
+  (obj: MetadataObject): OpenApi.IJsonSchema.IObject => {
+    // ITERATE PROPERTIES
+    const properties: Record<string, any> = {};
+    const extraMeta: ISuperfluous = {
+      patternProperties: {},
+      additionalProperties: undefined,
+    };
+    const required: string[] = [];
+
+    for (const property of obj.properties) {
+      if (
+        // FUNCTIONAL TYPE
+        property.value.functional === true &&
+        property.value.nullable === false &&
+        property.value.isRequired() === true &&
+        property.value.size() === 0
+      )
+        continue;
+      else if (property.jsDocTags.find((tag) => tag.name === "hidden"))
+        continue; // THE HIDDEN TAG
+
+      const key: string | null = property.key.getSoleLiteral();
+      const schema: OpenApi.IJsonSchema | null = application_v31_schema(true)(
+        components,
+      )({
+        deprecated:
+          property.jsDocTags.some((tag) => tag.name === "deprecated") ||
+          undefined,
+        title: (() => {
+          const info: IJsDocTagInfo | undefined = property.jsDocTags.find(
+            (tag) => tag.name === "title",
+          );
+          if (info?.text?.length) return CommentFactory.merge(info.text);
+          else if (!property.description?.length) return undefined;
+
+          const index: number = property.description.indexOf("\n");
+          const top: string = (
+            index === -1
+              ? property.description
+              : property.description.substring(0, index)
+          ).trim();
+          return top.endsWith(".")
+            ? top.substring(0, top.length - 1)
+            : undefined;
+        })(),
+        description: property.description ?? undefined,
+      })(property.value);
+
+      if (schema === null) continue;
+      if (key !== null) {
+        properties[key] = schema;
+        if (property.value.isRequired() === true) required.push(key);
+      } else {
+        const pattern: string = metadata_to_pattern(true)(property.key);
+        if (pattern === PatternUtil.STRING)
+          extraMeta.additionalProperties = [property.value, schema];
+        else extraMeta.patternProperties[pattern] = [property.value, schema];
+      }
+    }
+
+    return {
+      type: "object",
+      properties,
+      required: required.length ? required : undefined,
+      title: (() => {
+        const info: IJsDocTagInfo | undefined = obj.jsDocTags.find(
+          (tag) => tag.name === "title",
+        );
+        return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
+      })(),
+      description: obj.description,
+      additionalProperties: join(components)(extraMeta),
+    };
+  };
+
+/**
+ * @internal
+ */
+const join =
+  (components: OpenApi.IComponents) =>
+  (extra: ISuperfluous): OpenApi.IJsonSchema | undefined => {
+    // LIST UP METADATA
+    const elements: [Metadata, OpenApi.IJsonSchema][] = Object.values(
+      extra.patternProperties || {},
+    );
+    if (extra.additionalProperties) elements.push(extra.additionalProperties);
+
+    // SHORT RETURN
+    if (elements.length === 0) return undefined;
+    else if (elements.length === 1) return elements[0]![1]!;
+
+    // MERGE METADATA AND GENERATE VULNERABLE SCHEMA
+    const meta: Metadata = elements
+      .map((tuple) => tuple[0])
+      .reduce((x, y) => Metadata.merge(x, y));
+    return application_v31_schema(true)(components)({})(meta) ?? undefined;
+  };
+
+/**
+ * @internal
+ */
+interface ISuperfluous {
+  additionalProperties?: undefined | [Metadata, OpenApi.IJsonSchema];
+  patternProperties: Record<string, [Metadata, OpenApi.IJsonSchema]>;
+}

package/src/programmers/internal/application_v31_schema.ts

@@ -0,0 +1,150 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { application_array } from "./application_array";
+import { application_boolean } from "./application_boolean";
+import { application_escaped } from "./application_escaped";
+import { application_number } from "./application_number";
+import { application_string } from "./application_string";
+import { application_templates } from "./application_templates";
+import { application_v31_alias } from "./application_v31_alias";
+import { application_v31_constant } from "./application_v31_constant";
+import { application_v31_native } from "./application_v31_native";
+import { application_v31_object } from "./application_v31_object";
+import { application_v31_tuple } from "./application_v31_tuple";
+
+/**
+ * @internal
+ */
+export const application_v31_schema =
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: OpenApi.IComponents) =>
+  (attribute: OpenApi.IJsonSchema.__IAttribute) =>
+  (
+    meta: Metadata,
+  ): BlockNever extends true
+    ? OpenApi.IJsonSchema | null
+    : OpenApi.IJsonSchema => {
+    if (meta.any === true)
+      return {
+        ...attribute,
+        type: undefined,
+      };
+
+    //----
+    // GATHER UNION SCHEMAS
+    //----
+    const union: OpenApi.IJsonSchema[] = [];
+    const insert = (schema: OpenApi.IJsonSchema) => union.push(schema);
+
+    // NULLABLE
+    if (meta.nullable === true)
+      insert({
+        type: "null",
+      });
+
+    // toJSON() METHOD
+    if (meta.escaped !== null)
+      application_escaped(application_v31_schema(false)(components)({}))(
+        meta.escaped,
+      ).forEach(insert);
+
+    // ATOMIC TYPES
+    if (meta.templates.length && AtomicPredicator.template(meta))
+      insert(application_templates(meta));
+    for (const constant of meta.constants)
+      if (constant.type === "bigint") throw new TypeError(NO_BIGINT);
+      else if (AtomicPredicator.constant(meta)(constant.type) === false)
+        continue;
+      else application_v31_constant(constant).map(insert);
+    for (const a of meta.atomics)
+      if (a.type === "bigint") throw new TypeError(NO_BIGINT);
+      else if (a.type === "boolean") application_boolean(a).forEach(insert);
+      else if (a.type === "number") application_number(a).forEach(insert);
+      else if (a.type === "string") application_string(a).forEach(insert);
+
+    // ARRAY
+    for (const array of meta.arrays)
+      application_array(application_v31_schema(false)(components)({}))(
+        array,
+      ).forEach(insert);
+
+    // TUPLE
+    for (const tuple of meta.tuples)
+      insert(
+        application_v31_tuple(application_v31_schema(false)(components)({}))(
+          tuple,
+        ),
+      );
+
+    // NATIVES
+    for (const native of meta.natives)
+      if (AtomicPredicator.native(native)) {
+        const type: string = native.toLowerCase();
+        if (meta.atomics.some((a) => a.type === type)) continue;
+        else if (type === "bigint") throw new TypeError(NO_BIGINT);
+        else if (type === "boolean")
+          insert(
+            application_boolean(
+              MetadataAtomic.create({
+                type: "boolean",
+                tags: [],
+              }),
+            )[0]!,
+          );
+        else if (type === "number")
+          insert(
+            application_number(
+              MetadataAtomic.create({
+                type: "number",
+                tags: [],
+              }),
+            )[0]!,
+          );
+        else if (type === "string")
+          insert(
+            application_string(
+              MetadataAtomic.create({
+                type: "string",
+                tags: [],
+              }),
+            )[0]!,
+          );
+      } else insert(application_v31_native(components)(native));
+    if (meta.sets.length) insert(application_v31_native(components)(`Set`));
+    if (meta.maps.length) insert(application_v31_native(components)(`Map`));
+
+    // OBJECT
+    for (const obj of meta.objects)
+      insert(application_v31_object(components)(obj));
+
+    // ALIASES
+    for (const alias of meta.aliases)
+      insert(application_v31_alias(blockNever)(components)(alias));
+
+    //----
+    // RETURNS
+    //----
+    if (union.length === 0 && blockNever === true) return null!;
+    const schema: OpenApi.IJsonSchema =
+      union.length === 0
+        ? { type: undefined }
+        : union.length === 1
+          ? union[0]!
+          : { oneOf: union };
+    return {
+      ...schema,
+      ...attribute,
+      title: attribute.title ?? schema.title,
+      description: attribute.description ?? schema.description,
+      deprecated: attribute.deprecated ?? schema.deprecated,
+    };
+  };
+
+/**
+ * @internal
+ */
+const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/application_v31_tuple.ts

@@ -0,0 +1,22 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+
+/**
+ * @internal
+ */
+export const application_v31_tuple =
+  (generator: (meta: Metadata) => OpenApi.IJsonSchema) =>
+  (tuple: MetadataTuple): OpenApi.IJsonSchema.ITuple => {
+    const tail: Metadata | undefined = tuple.type.elements.at(-1);
+    const prefixItems: Metadata[] = tuple.type.isRest()
+      ? tuple.type.elements.slice(0, -1)
+      : tuple.type.elements;
+    return {
+      type: "array",
+      items: undefined!,
+      prefixItems: prefixItems.map(generator),
+      additionalItems: tail ? generator(tail) : false,
+    };
+  };

package/src/programmers/internal/check_dynamic_key.ts

@@ -97,7 +97,7 @@ export const check_dynamic_key =
 
     // CONSTANTS
     for (const constant of metadata.constants)
-      for (const value of constant.values)
+      for (const { value } of constant.values)
         conditions.push(
           ts.factory.createStrictEquality(
             ts.factory.createStringLiteral(String(value)),
@@ -153,12 +153,12 @@ export const check_dynamic_key =
     return conditions.length === 0
       ? ts.factory.createTrue()
       : conditions.length === 1
-      ? conditions[0]!
-      : conditions.reduce(ts.factory.createLogicalOr);
+        ? conditions[0]!
+        : conditions.reduce(ts.factory.createLogicalOr);
   };
 
-const atomist = (entry: ICheckEntry) => {
-  return [
+const atomist = (entry: ICheckEntry) =>
+  [
     ...(entry.expression ? [entry.expression] : []),
     ...(entry.conditions.length === 0
       ? []
@@ -172,4 +172,3 @@ const atomist = (entry: ICheckEntry) => {
             .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
         ]),
   ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-};

package/src/programmers/internal/check_dynamic_properties.ts

@@ -123,6 +123,7 @@ const check_dynamic_property =
           ts.factory.createReturnStatement(output),
         ),
       );
+    const broken = { value: false };
 
     // GATHER CONDITIONS
     if (regular.length) add(is_regular_property(regular), props.positive);
@@ -141,11 +142,17 @@ const check_dynamic_property =
         props.positive,
       );
 
-    for (const entry of dynamic)
-      add(
-        check_dynamic_key(project)(importer)(key, entry.key),
-        entry.expression,
+    for (const entry of dynamic) {
+      const condition: ts.Expression = check_dynamic_key(project)(importer)(
+        key,
+        entry.key,
       );
+      if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+        statements.push(ts.factory.createReturnStatement(entry.expression));
+        broken.value = true;
+        break;
+      } else add(condition, entry.expression);
+    }
 
     //----
     // FUNCTION BODY
@@ -154,9 +161,15 @@ const check_dynamic_property =
     const block: ts.Block = ts.factory.createBlock(
       [
         ...statements,
-        ts.factory.createReturnStatement(
-          props.equals === true ? props.superfluous(value) : props.positive,
-        ),
+        ...(broken.value
+          ? []
+          : [
+              ts.factory.createReturnStatement(
+                props.equals === true
+                  ? props.superfluous(value)
+                  : props.positive,
+              ),
+            ]),
       ],
       true,
     );

package/src/programmers/internal/check_number.ts

@@ -29,14 +29,14 @@ export const check_number =
               [input],
             )
           : OptionPredicator.numeric(project.options)
-          ? ts.factory.createLogicalNot(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Number.isNaN"),
-                undefined,
-                [input],
-              ),
-            )
-          : null
+            ? ts.factory.createLogicalNot(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("Number.isNaN"),
+                  undefined,
+                  [input],
+                ),
+              )
+            : null
         : null;
 
     const conditions: ICheckEntry.ICondition[][] =
@@ -67,35 +67,36 @@ const check_numeric_type_tags =
         ...(addition === null
           ? []
           : row.some(
-              (tag) =>
-                tag.kind === "type" &&
-                (tag.value === "int32" ||
-                  tag.value === "uint32" ||
-                  tag.value === "int64" ||
-                  tag.value === "uint64" ||
-                  tag.value === "float"),
-            ) ||
-            row.some(
-              (tag) =>
-                tag.kind === "multipleOf" && typeof tag.value === "number",
-            ) ||
-            (row.some(
-              (tag) =>
-                (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
-                typeof tag.value === "number",
-            ) &&
+                (tag) =>
+                  tag.kind === "type" &&
+                  (tag.value === "int32" ||
+                    tag.value === "uint32" ||
+                    tag.value === "int64" ||
+                    tag.value === "uint64" ||
+                    tag.value === "float"),
+              ) ||
               row.some(
                 (tag) =>
-                  (tag.kind === "maximum" || tag.kind === "exclusiveMaximum") &&
+                  tag.kind === "multipleOf" && typeof tag.value === "number",
+              ) ||
+              (row.some(
+                (tag) =>
+                  (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
                   typeof tag.value === "number",
-              ))
-          ? []
-          : [
-              {
-                expected: "number",
-                expression: addition!,
-              },
-            ]),
+              ) &&
+                row.some(
+                  (tag) =>
+                    (tag.kind === "maximum" ||
+                      tag.kind === "exclusiveMaximum") &&
+                    typeof tag.value === "number",
+                ))
+            ? []
+            : [
+                {
+                  expected: "number",
+                  expression: addition!,
+                },
+              ]),
         ...row.map((tag) => ({
           expected: `number & ${tag.name}`,
           expression: (

package/src/programmers/internal/check_object.ts

@@ -54,7 +54,8 @@ export namespace check_object {
 /**
  * @internal
  */
-const reduce = (props: check_object.IProps) => (expressions: ts.Expression[]) =>
-  props.assert
-    ? expressions.reduce(props.reduce)
-    : check_everything(ts.factory.createArrayLiteralExpression(expressions));
+const reduce =
+  (props: check_object.IProps) => (expressions: ts.Expression[]) =>
+    props.assert
+      ? expressions.reduce(props.reduce)
+      : check_everything(ts.factory.createArrayLiteralExpression(expressions));

package/src/programmers/internal/check_template.ts

@@ -48,7 +48,7 @@ export const check_template =
             tpl
               .map((child) =>
                 child.isConstant() && child.size() === 1
-                  ? child.constants[0]!.values[0]!
+                  ? child.constants[0]!.values[0]!.value
                   : `$\{${child.getName()}\}`,
               )
               .join("")

package/src/programmers/internal/decode_union_object.ts

@@ -52,24 +52,45 @@ export const decode_union_object =
 
 const iterate =
   (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
-  (input: ts.Expression, unions: IUnion[], expected: string) =>
-    ts.factory.createBlock(
-      [
-        unions
-          .map((u, i) =>
-            ts.factory.createIfStatement(
-              u.is(),
-              ts.factory.createReturnStatement(u.value()),
-              i === unions.length - 1 ? escaper(input, expected) : undefined,
-            ),
+  (input: ts.Expression, unions: IUnion[], expected: string) => {
+    interface IBranch {
+      condition: null | ts.Expression;
+      value: ts.Expression;
+    }
+    const branches: IBranch[] = [];
+
+    for (const u of unions) {
+      const condition: ts.Expression = u.is();
+      if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+        branches.push({
+          condition: null,
+          value: u.value(),
+        });
+        break;
+      }
+      branches.push({
+        condition,
+        value: u.value(),
+      });
+    }
+    if (branches.length === 0)
+      return ts.factory.createBlock([escaper(input, expected)], true);
+    else if (branches.length === 1 && branches[0]!.condition === null)
+      return branches[0]!.value;
+
+    const statements: ts.Statement[] = branches.map((b) =>
+      b.condition !== null
+        ? ts.factory.createIfStatement(
+            b.condition,
+            ts.factory.createReturnStatement(b.value),
+            undefined,
           )
-          .reverse()
-          .reduce((a, b) =>
-            ts.factory.createIfStatement(b.expression, b.thenStatement, a),
-          ),
-      ],
-      true,
+        : ts.factory.createReturnStatement(b.value),
     );
+    if (branches.at(-1)!.condition !== null)
+      statements.push(escaper(input, expected));
+    return ts.factory.createBlock(statements, true);
+  };
 
 interface IUnion {
   type: string;

package/src/programmers/internal/feature_object_entries.ts

@@ -28,14 +28,14 @@ export const feature_object_entries =
         sole === null
           ? ts.factory.createIdentifier("value")
           : Escaper.variable(sole)
-          ? ts.factory.createPropertyAccessExpression(
-              input,
-              ts.factory.createIdentifier(sole),
-            )
-          : ts.factory.createElementAccessExpression(
-              input,
-              ts.factory.createStringLiteral(sole),
-            );
+            ? ts.factory.createPropertyAccessExpression(
+                input,
+                ts.factory.createIdentifier(sole),
+              )
+            : ts.factory.createElementAccessExpression(
+                input,
+                ts.factory.createStringLiteral(sole),
+              );
 
       return {
         input: propInput,

package/src/programmers/internal/metadata_to_pattern.ts

@@ -1,6 +1,5 @@
 import { Metadata } from "../../schemas/metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
 import { PatternUtil } from "../../utils/PatternUtil";
 
 import { template_to_pattern } from "./template_to_pattern";
@@ -14,12 +13,14 @@ export const metadata_to_pattern =
     if (meta.atomics.find((a) => a.type === "string") !== undefined)
       return "(.*)";
 
-    const values: string[] = ArrayUtil.flat(
-      meta.constants.map((c) => {
+    const values: string[] = meta.constants
+      .map((c) => {
         if (c.type !== "string") return c.values.map((v) => v.toString());
-        return (c.values as string[]).map((str) => PatternUtil.escape(str));
-      }),
-    );
+        return (c.values.map((v) => v.value) as string[]).map((str) =>
+          PatternUtil.escape(str),
+        );
+      })
+      .flat();
     for (const a of meta.atomics)
       if (a.type === "number" || a.type === "bigint")
         values.push(PatternUtil.NUMBER);