typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/internal/application_string.ts

@@ -1,61 +1,25 @@
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { Metadata } from "../../schemas/metadata/Metadata";
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_default_string } from "./application_default_string";
+import { application_plugin } from "./application_plugin";
 
 /**
  * @internal
  */
-export const application_string =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (meta: Metadata) =>
-  (atomic: MetadataAtomic) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IString[] => {
-    // DEFAULT CONFIGURATION
-    const base: IJsonSchema.IString = {
+export const application_string = <Version extends "3.0" | "3.1">(
+  atomic: MetadataAtomic,
+): Schema<Version>[] =>
+  application_plugin(
+    {
       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)];
-
-    // CONSIDER TYPE TAGS
-    const union: IJsonSchema.IString[] = atomic.tags.map(
-      (row) => application_string_tags(options)({ ...base })(row)!,
-    );
-    const map: Map<string, IJsonSchema.IString> = new Map(
-      union.map((u) => [JSON.stringify(u), u]),
-    );
-    return [...map.values()].map((s) => out(s));
-  };
+    } satisfies Schema<Version>,
+    atomic.tags,
+  );
 
-const application_string_tags =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (base: 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")
-        base.minLength = tag.value;
-      else if (tag.kind === "maxLength" && typeof tag.value === "number")
-        base.maxLength = tag.value;
-      else if (tag.kind === "format" && typeof tag.value === "string")
-        base.format = tag.value;
-      else if (tag.kind === "pattern") base.pattern = tag.value;
-      else if (tag.kind === "default" && typeof tag.value === "string")
-        base.default = tag.value;
-    if (options.surplus)
-      base["x-typia-typeTags"] = row.map((tag) => ({
-        target: tag.target,
-        name: tag.name,
-        kind: tag.kind,
-        value: tag.value,
-        validate: tag.validate,
-        exclusive: tag.exclusive,
-      }));
-    return base;
-  };
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IString
+  : OpenApi.IJsonSchema.IString;

package/src/programmers/internal/application_templates.ts

@@ -1,24 +1,25 @@
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
 import { Metadata } from "../../schemas/metadata/Metadata";
 
-import { application_default_string } from "./application_default_string";
 import { metadata_to_pattern } from "./metadata_to_pattern";
 
 /**
  * @internal
  */
-export const application_templates =
-  (meta: Metadata) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IString => {
-    // CONSTRUCT PATTERN
-    const output: IJsonSchema.IString = {
-      type: "string",
-    };
-    output.pattern = metadata_to_pattern(true)(meta);
-
-    // DEFAULT VALUE
-    output.default = application_default_string(meta)(attribute)(output);
-
-    // RETURNS
-    return output;
+export const application_templates = <Version extends "3.0" | "3.1">(
+  meta: Metadata,
+): Schema<Version> => {
+  const output: Schema<Version> = {
+    type: "string",
   };
+  output.pattern = metadata_to_pattern(true)(meta);
+  return output;
+};
+
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IString
+  : OpenApi.IJsonSchema.IString;

package/src/programmers/internal/application_v30_alias.ts

@@ -0,0 +1,51 @@
+import { OpenApiV3 } from "@samchon/openapi";
+
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
+import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
+
+import { application_v30_object } from "./application_v30_object";
+import { application_v30_schema } from "./application_v30_schema";
+
+/**
+ * @internal
+ */
+export const application_v30_alias =
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: OpenApiV3.IComponents) =>
+  (alias: MetadataAlias) =>
+  (nullable: boolean): OpenApiV3.IJsonSchema.IReference => {
+    if (alias.value.size() === 1 && alias.value.objects.length === 1)
+      return application_v30_object(components)(alias.value.objects[0]!)(
+        nullable,
+      ) as OpenApiV3.IJsonSchema.IReference;
+
+    const key: string = `${alias.name}${nullable ? ".Nullable" : ""}`;
+    const $ref: string = `#/components/schemas/${key}`;
+
+    if (components.schemas?.[key] === undefined) {
+      // TEMPORARY ASSIGNMENT
+      components.schemas ??= {};
+      components.schemas[key] = {};
+
+      // GENERATE SCHEMA
+      const schema: OpenApiV3.IJsonSchema | null = application_v30_schema(
+        blockNever,
+      )(components)({
+        deprecated:
+          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
+        title: (() => {
+          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
+            (tag) => tag.name === "title",
+          );
+          return info?.text?.length
+            ? CommentFactory.merge(info.text)
+            : undefined;
+        })(),
+        description: alias.description ?? undefined,
+      })(alias.value);
+      if (schema !== null) Object.assign(components.schemas[key]!, schema);
+    }
+    return { $ref };
+  };

package/src/programmers/internal/application_v30_constant.ts

@@ -0,0 +1,18 @@
+import { OpenApiV3 } from "@samchon/openapi";
+
+import { MetadataConstant } from "../../schemas/metadata/MetadataConstant";
+
+/**
+ * @internal
+ */
+export const application_v30_constant = (
+  constant: MetadataConstant,
+):
+  | OpenApiV3.IJsonSchema.IBoolean
+  | OpenApiV3.IJsonSchema.IInteger
+  | OpenApiV3.IJsonSchema.INumber
+  | OpenApiV3.IJsonSchema.IString => ({
+  type: constant.type as "string" | "number" | "boolean" | "integer",
+  enum: constant.values.map((v) => v.value) as any,
+  // @todo default
+});

package/src/programmers/internal/application_v30_native.ts

@@ -0,0 +1,28 @@
+import { OpenApiV3 } from "@samchon/openapi";
+
+/**
+ * @internal
+ */
+export const application_v30_native =
+  (components: OpenApiV3.IComponents) =>
+  (name: string) =>
+  (nullable: boolean): OpenApiV3.IJsonSchema => {
+    if (name === "Blob" || name === "File")
+      return {
+        type: "string",
+        format: "binary",
+        nullable,
+      };
+    const key: string = `${name}${nullable ? ".Nullable" : ""}`;
+    if (components.schemas?.[key] === undefined) {
+      components.schemas ??= {};
+      components.schemas[key] ??= {
+        type: "object",
+        properties: {},
+        nullable,
+      };
+    }
+    return {
+      $ref: `#/components/schemas/${key}`,
+    };
+  };

package/src/programmers/internal/application_v30_object.ts

@@ -0,0 +1,148 @@
+import { 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_v30_schema } from "./application_v30_schema";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const application_v30_object =
+  (components: OpenApiV3.IComponents) =>
+  (obj: MetadataObject) =>
+  (
+    nullable: boolean,
+  ): OpenApiV3.IJsonSchema.IReference | OpenApiV3.IJsonSchema.IObject => {
+    if (obj._Is_literal() === true)
+      return create_object_schema(components)(obj)(nullable);
+
+    const key: string = `${obj.name}${nullable ? ".Nullable" : ""}`;
+    const $ref: string = `#/components/schemas/${key}`;
+    if (components.schemas?.[key] !== undefined) return { $ref };
+
+    const object: OpenApiV3.IJsonSchema = {};
+    components.schemas ??= {};
+    components.schemas[key] = object;
+    Object.assign(object, create_object_schema(components)(obj)(nullable));
+    return { $ref };
+  };
+
+/**
+ * @internal
+ */
+const create_object_schema =
+  (components: OpenApiV3.IComponents) =>
+  (obj: MetadataObject) =>
+  (nullable: boolean): OpenApiV3.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: OpenApiV3.IJsonSchema | null = application_v30_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,
+      nullable,
+      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: OpenApiV3.IComponents) =>
+  (extra: ISuperfluous): OpenApiV3.IJsonSchema | undefined => {
+    // LIST UP METADATA
+    const elements: [Metadata, OpenApiV3.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_v30_schema(true)(components)({})(meta) ?? undefined;
+  };
+
+/**
+ * @internal
+ */
+interface ISuperfluous {
+  additionalProperties?: undefined | [Metadata, OpenApiV3.IJsonSchema];
+  patternProperties: Record<string, [Metadata, OpenApiV3.IJsonSchema]>;
+}

package/src/programmers/internal/application_v30_schema.ts

@@ -0,0 +1,155 @@
+import { OpenApiV3 } 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_v30_alias } from "./application_v30_alias";
+import { application_v30_constant } from "./application_v30_constant";
+import { application_v30_native } from "./application_v30_native";
+import { application_v30_object } from "./application_v30_object";
+import { application_v30_tuple } from "./application_v30_tuple";
+
+/**
+ * @internal
+ */
+export const application_v30_schema =
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: OpenApiV3.IComponents) =>
+  (attribute: OpenApiV3.IJsonSchema.__IAttribute) =>
+  (
+    meta: Metadata,
+  ): BlockNever extends true
+    ? OpenApiV3.IJsonSchema | null
+    : OpenApiV3.IJsonSchema => {
+    // VULNERABLE CASE
+    if (meta.any === true)
+      return {
+        ...attribute,
+        type: undefined,
+      };
+    else if (meta.nullable && meta.empty())
+      return { type: "null", ...attribute };
+
+    //----
+    // GATHER UNION SCHEMAS
+    //----
+    const union: OpenApiV3.IJsonSchema[] = [];
+    const insert = meta.nullable
+      ? (schema: OpenApiV3.IJsonSchema) =>
+          union.push({
+            ...schema,
+            nullable: (schema as OpenApiV3.IJsonSchema.__ISignificant<any>).type
+              ? true
+              : undefined,
+          } as OpenApiV3.IJsonSchema)
+      : (schema: OpenApiV3.IJsonSchema) => union.push(schema);
+
+    // toJSON() METHOD
+    if (meta.escaped !== null)
+      application_escaped(application_v30_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 insert(application_v30_constant(constant));
+    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_v30_schema(false)(components)({}))(
+        array,
+      ).forEach(insert);
+
+    // TUPLE
+    for (const tuple of meta.tuples)
+      insert(application_v30_tuple(components)(tuple)(attribute));
+
+    // 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_v30_native(components)(native)(meta.nullable));
+    if (meta.sets.length)
+      insert(application_v30_native(components)(`Set`)(meta.nullable));
+    if (meta.maps.length)
+      insert(application_v30_native(components)(`Map`)(meta.nullable));
+
+    // OBJECT
+    for (const obj of meta.objects)
+      insert(application_v30_object(components)(obj)(meta.nullable));
+
+    // ALIASES
+    for (const alias of meta.aliases)
+      insert(
+        application_v30_alias(blockNever)(components)(alias)(meta.nullable),
+      );
+
+    //----
+    // RETURNS
+    //----
+    if (union.length === 0 && blockNever === true) return null!;
+    const schema: OpenApiV3.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_v30_tuple.ts

@@ -0,0 +1,33 @@
+import { OpenApiV3 } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+
+import { application_v30_schema } from "./application_v30_schema";
+
+/**
+ * @internal
+ */
+export const application_v30_tuple =
+  (components: OpenApiV3.IComponents) =>
+  (tuple: MetadataTuple) =>
+  (
+    attribute: OpenApiV3.IJsonSchema.__IAttribute,
+  ): OpenApiV3.IJsonSchema.IArray => ({
+    ...attribute,
+    type: "array",
+    items: application_v30_schema(false)(components)(
+      tuple.type.recursive ? {} : attribute,
+    )(
+      tuple.type.elements.reduce(
+        (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
+        Metadata.initialize(),
+      ),
+    ),
+    minItems: !!tuple.type.elements.at(-1)?.rest
+      ? tuple.type.elements.length - 1
+      : tuple.type.elements.filter((x) => !x.optional).length,
+    maxItems: !!tuple.type.elements.at(-1)?.rest
+      ? undefined!
+      : tuple.type.elements.length,
+  });

package/src/programmers/internal/application_v31_alias.ts

@@ -0,0 +1,43 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
+import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
+
+import { application_v31_schema } from "./application_v31_schema";
+
+/**
+ * @internal
+ */
+export const application_v31_alias =
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: OpenApi.IComponents) =>
+  (alias: MetadataAlias): OpenApi.IJsonSchema.IReference => {
+    const $ref: string = `#/components/schemas/${alias.name}`;
+    if (components.schemas?.[alias.name] === undefined) {
+      // TEMPORARY ASSIGNMENT
+      components.schemas ??= {};
+      components.schemas[alias.name] = {};
+
+      // GENERATE SCHEMA
+      const schema: OpenApi.IJsonSchema | null = application_v31_schema(
+        blockNever,
+      )(components)({
+        deprecated:
+          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
+        title: (() => {
+          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
+            (tag) => tag.name === "title",
+          );
+          return info?.text?.length
+            ? CommentFactory.merge(info.text)
+            : undefined;
+        })(),
+        description: alias.description ?? undefined,
+      })(alias.value);
+      if (schema !== null)
+        Object.assign(components.schemas[alias.name]!, schema);
+    }
+    return { $ref };
+  };

package/src/programmers/internal/application_v31_constant.ts

@@ -0,0 +1,22 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { MetadataConstant } from "../../schemas/metadata/MetadataConstant";
+
+import { application_plugin } from "./application_plugin";
+
+/**
+ * @internal
+ */
+export const application_v31_constant = (
+  constant: MetadataConstant,
+): OpenApi.IJsonSchema.IConstant[] =>
+  constant.values
+    .map((value) =>
+      application_plugin(
+        {
+          const: value.value as boolean | number | string,
+        } satisfies OpenApi.IJsonSchema.IConstant,
+        value.tags ?? [],
+      ),
+    )
+    .flat();

package/src/programmers/internal/application_v31_native.ts

@@ -0,0 +1,24 @@
+import { OpenApi } from "@samchon/openapi";
+
+/**
+ * @internal
+ */
+export const application_v31_native =
+  (components: OpenApi.IComponents) =>
+  (name: string): OpenApi.IJsonSchema => {
+    if (name === "Blob" || name === "File")
+      return {
+        type: "string",
+        format: "binary",
+      };
+    if (components.schemas?.[name] === undefined) {
+      components.schemas ??= {};
+      components.schemas[name] ??= {
+        type: "object",
+        properties: {},
+      };
+    }
+    return {
+      $ref: `#/components/schemas/${name}`,
+    };
+  };