typia 6.10.0-dev.20240823 → 6.10.0-dev.20240908

package/src/programmers/RandomProgrammer.ts

@@ -276,7 +276,7 @@ export namespace RandomProgrammer {
         expressions.push(ts.factory.createStringLiteral("any type used..."));
 
       // NULL COALESCING
-      if (meta.isRequired() === false || meta.functional === true)
+      if (meta.isRequired() === false || meta.functions.length)
         expressions.push(ts.factory.createIdentifier("undefined"));
       if (meta.nullable === true) expressions.push(ts.factory.createNull());
 

package/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts

@@ -9,7 +9,9 @@ export namespace FunctionalGeneralProgrammer {
   }
   export const getReturnType =
     (checker: ts.TypeChecker) =>
-    (declaration: ts.FunctionDeclaration): IOutput => {
+    (
+      declaration: ts.FunctionDeclaration | ts.SignatureDeclaration,
+    ): IOutput => {
       const signature: ts.Signature | undefined =
         checker.getSignatureFromDeclaration(declaration);
       const type: ts.Type =

package/src/programmers/internal/application_escaped.ts

@@ -1,76 +1,74 @@
-import { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
-
-/**
- * @internal
- */
-export const application_escaped =
-  <Version extends "3.0" | "3.1">(
-    generator: (meta: Metadata) => Schema<Version>,
-  ) =>
-  (resolved: MetadataEscaped): Schema<Version>[] => {
-    const output: Schema<Version> | null = generator(resolved.returns);
-    if (output === null) return [];
-
-    if (is_date(new Set())(resolved.original)) {
-      const string: StringSchema<Version> | undefined = is_string(output)
-        ? output
-        : is_one_of(output)
-          ? (output.oneOf.find(is_string) as StringSchema<Version>)
-          : undefined;
-      if (
-        string !== undefined &&
-        string.format !== "date" &&
-        string.format !== "date-time"
-      )
-        string.format = "date-time";
-    }
-    return is_one_of(output)
-      ? (output.oneOf as OneOfSchema<Version>[])
-      : [output];
-  };
-
-/**
- * @internal
- */
-const is_string = <Version extends "3.0" | "3.1">(
-  elem: Schema<Version>,
-): elem is StringSchema<Version> =>
-  (elem as StringSchema<Version>).type === "string";
-
-/**
- * @internal
- */
-const is_one_of = <Version extends "3.0" | "3.1">(
-  elem: Schema<Version>,
-): elem is OneOfSchema<Version> =>
-  Array.isArray((elem as OneOfSchema<Version>).oneOf);
-
-/**
- * @internal
- */
-const is_date =
-  (visited: Set<Metadata>) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
-
-    return (
-      meta.natives.some((name) => name === "Date") ||
-      meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
-      meta.tuples.some((tuple) => tuple.type.elements.some(is_date(visited))) ||
-      meta.aliases.some((alias) => is_date(visited)(alias.value))
-    );
-  };
-
-type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema
-  : OpenApi.IJsonSchema;
-type StringSchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema.IString
-  : OpenApi.IJsonSchema.IString;
-type OneOfSchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
-  ? OpenApiV3.IJsonSchema.IOneOf
-  : OpenApi.IJsonSchema.IOneOf;
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
+
+/**
+ * @internal
+ */
+export const application_escaped =
+  <Version extends "3.0" | "3.1">(
+    generator: (meta: Metadata) => Schema<Version>,
+  ) =>
+  (escaped: MetadataEscaped): Schema<Version>[] => {
+    const output: Schema<Version> | null = generator(escaped.returns);
+    if (output === null) return [];
+
+    if (is_date(new Set())(escaped.original)) {
+      const string: StringSchema<Version> | undefined = is_string(output)
+        ? output
+        : is_one_of(output)
+          ? (output.oneOf.find(is_string) as StringSchema<Version>)
+          : undefined;
+      if (
+        string !== undefined &&
+        string.format !== "date" &&
+        string.format !== "date-time"
+      )
+        string.format = "date-time";
+    }
+    return is_one_of(output) ? (output.oneOf as Schema<Version>[]) : [output];
+  };
+
+/**
+ * @internal
+ */
+const is_string = <Version extends "3.0" | "3.1">(
+  elem: Schema<Version>,
+): elem is StringSchema<Version> =>
+  (elem as StringSchema<Version>).type === "string";
+
+/**
+ * @internal
+ */
+const is_one_of = <Version extends "3.0" | "3.1">(
+  elem: Schema<Version>,
+): elem is OneOfSchema<Version> =>
+  Array.isArray((elem as OneOfSchema<Version>).oneOf);
+
+/**
+ * @internal
+ */
+const is_date =
+  (visited: Set<Metadata>) =>
+  (meta: Metadata): boolean => {
+    if (visited.has(meta)) return false;
+    visited.add(meta);
+
+    return (
+      meta.natives.some((name) => name === "Date") ||
+      meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
+      meta.tuples.some((tuple) => tuple.type.elements.some(is_date(visited))) ||
+      meta.aliases.some((alias) => is_date(visited)(alias.value))
+    );
+  };
+
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema
+  : OpenApi.IJsonSchema;
+type StringSchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IString
+  : OpenApi.IJsonSchema.IString;
+type OneOfSchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IOneOf
+  : OpenApi.IJsonSchema.IOneOf;

package/src/programmers/internal/application_v30_object.ts

@@ -53,7 +53,7 @@ const create_object_schema =
     for (const property of obj.properties) {
       if (
         // FUNCTIONAL TYPE
-        property.value.functional === true &&
+        property.value.functions.length &&
         property.value.nullable === false &&
         property.value.isRequired() === true &&
         property.value.size() === 0

package/src/programmers/internal/application_v31_object.ts

@@ -51,7 +51,7 @@ const create_object_schema =
     for (const property of obj.properties) {
       if (
         // FUNCTIONAL TYPE
-        property.value.functional === true &&
+        property.value.functions.length &&
         property.value.nullable === false &&
         property.value.isRequired() === true &&
         property.value.size() === 0

package/src/programmers/internal/llm_schema_array.ts

@@ -0,0 +1,22 @@
+import { ILlmSchema } from "@samchon/openapi";
+
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { application_plugin } from "./application_plugin";
+import { llm_schema_station } from "./llm_schema_station";
+
+/**
+ * @internal
+ */
+export const llm_schema_array = (array: MetadataArray): ILlmSchema.IArray[] =>
+  application_plugin(
+    {
+      type: "array",
+      items: llm_schema_station({
+        metadata: array.type.value,
+        blockNever: false,
+        attribute: {},
+      }),
+    },
+    array.tags,
+  );

package/src/programmers/internal/llm_schema_escaped.ts

@@ -0,0 +1,61 @@
+import { ILlmSchema } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
+
+import { llm_schema_station } from "./llm_schema_station";
+
+/**
+ * @internal
+ */
+export const llm_schema_escaped = (escaped: MetadataEscaped): ILlmSchema[] => {
+  const output: ILlmSchema | null = llm_schema_station({
+    metadata: escaped.returns,
+    blockNever: false,
+    attribute: {},
+  });
+  if (output === null) return [];
+  else if (is_date(new Set())(escaped.original)) {
+    const string: ILlmSchema.IString | undefined = is_string(output)
+      ? output
+      : is_one_of(output)
+        ? (output.oneOf.find(is_string) as ILlmSchema.IString)
+        : undefined;
+    if (
+      string !== undefined &&
+      string.format !== "date" &&
+      string.format !== "date-time"
+    )
+      string.format = "date-time";
+  }
+  return is_one_of(output) ? (output.oneOf as ILlmSchema[]) : [output];
+};
+
+/**
+ * @internal
+ */
+const is_string = (elem: ILlmSchema): elem is ILlmSchema.IString =>
+  (elem as ILlmSchema.IString).type === "string";
+
+/**
+ * @internal
+ */
+const is_one_of = (elem: ILlmSchema): elem is ILlmSchema.IOneOf =>
+  Array.isArray((elem as ILlmSchema.IOneOf).oneOf);
+
+/**
+ * @internal
+ */
+const is_date =
+  (visited: Set<Metadata>) =>
+  (meta: Metadata): boolean => {
+    if (visited.has(meta)) return false;
+    visited.add(meta);
+
+    return (
+      meta.natives.some((name) => name === "Date") ||
+      meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
+      meta.tuples.some((tuple) => tuple.type.elements.some(is_date(visited))) ||
+      meta.aliases.some((alias) => is_date(visited)(alias.value))
+    );
+  };

package/src/programmers/internal/llm_schema_native.ts

@@ -0,0 +1,17 @@
+import { ILlmSchema } from "@samchon/openapi";
+
+/**
+ * @internal
+ */
+export const llm_schema_native = (
+  name: string,
+): ILlmSchema.IString | ILlmSchema.IObject =>
+  name === "Blob" || name === "File"
+    ? {
+        type: "string",
+        format: "binary",
+      }
+    : {
+        type: "object",
+        properties: {},
+      };

package/src/programmers/internal/llm_schema_object.ts

@@ -0,0 +1,129 @@
+import { ILlmSchema } 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_description } from "./application_description";
+import { llm_schema_station } from "./llm_schema_station";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const llm_schema_object = (props: {
+  object: MetadataObject;
+  nullable: boolean;
+}): ILlmSchema.IObject => {
+  // ITERATE PROPERTIES
+  const properties: Record<string, any> = {};
+  const extraMeta: ISuperfluous = {
+    patternProperties: {},
+    additionalProperties: undefined,
+  };
+  const required: string[] = [];
+
+  for (const property of props.object.properties) {
+    if (
+      // FUNCTIONAL TYPE
+      property.value.functions.length &&
+      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: ILlmSchema | null = llm_schema_station({
+      blockNever: true,
+      attribute: {
+        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: application_description(property),
+      },
+      metadata: 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: props.nullable,
+    required: required.length ? required : undefined,
+    title: (() => {
+      const info: IJsDocTagInfo | undefined = props.object.jsDocTags.find(
+        (tag) => tag.name === "title",
+      );
+      return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
+    })(),
+    description: application_description(props.object),
+    additionalProperties: join(extraMeta),
+  };
+};
+
+/**
+ * @internal
+ */
+const join = (extra: ISuperfluous): ILlmSchema | undefined => {
+  // LIST UP METADATA
+  const elements: [Metadata, ILlmSchema][] = 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 llm_schema_station({
+    blockNever: true,
+    attribute: {},
+    metadata: meta,
+  });
+};
+
+/**
+ * @internal
+ */
+interface ISuperfluous {
+  additionalProperties?: undefined | [Metadata, ILlmSchema];
+  patternProperties: Record<string, [Metadata, ILlmSchema]>;
+}

package/src/programmers/internal/llm_schema_station.ts

@@ -0,0 +1,185 @@
+import { ILlmSchema } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { application_bigint } from "./application_bigint";
+import { application_boolean } from "./application_boolean";
+import { application_number } from "./application_number";
+import { application_string } from "./application_string";
+import { application_templates } from "./application_templates";
+import { application_v30_constant } from "./application_v30_constant";
+import { llm_schema_array } from "./llm_schema_array";
+import { llm_schema_escaped } from "./llm_schema_escaped";
+import { llm_schema_native } from "./llm_schema_native";
+import { llm_schema_object } from "./llm_schema_object";
+import { llm_schema_tuple } from "./llm_schema_tuple";
+
+/**
+ * @internal
+ */
+export const llm_schema_station = (props: {
+  metadata: Metadata;
+  blockNever: boolean;
+  attribute: ILlmSchema.__IAttribute;
+}): ILlmSchema => {
+  // VULNERABLE CASE
+  if (props.metadata.any === true)
+    return {
+      ...props.attribute,
+      type: undefined,
+    };
+  else if (props.metadata.nullable === true && props.metadata.empty() === true)
+    return {
+      ...props.attribute,
+      type: "null",
+    };
+
+  //----
+  // GATHER UNION SCHEMAS
+  //----
+  const union: ILlmSchema[] = [];
+  const insert = props.metadata.nullable
+    ? (schema: ILlmSchema) =>
+        union.push({
+          ...schema,
+          nullable: (schema as ILlmSchema.__ISignificant<any>).type
+            ? true
+            : undefined,
+        } as ILlmSchema)
+    : (schema: ILlmSchema) => union.push(schema);
+
+  // toJSON() METHOD
+  if (props.metadata.escaped !== null)
+    llm_schema_escaped(props.metadata.escaped).forEach(insert);
+
+  // ATOMIC TYPES
+  if (
+    props.metadata.templates.length &&
+    AtomicPredicator.template(props.metadata)
+  )
+    application_templates<"3.0">(props.metadata).map(insert);
+  for (const constant of props.metadata.constants)
+    if (AtomicPredicator.constant(props.metadata)(constant.type) === false)
+      continue;
+    else insert(application_v30_constant(constant));
+  for (const a of props.metadata.atomics)
+    if (a.type === "boolean") application_boolean<"3.0">(a).forEach(insert);
+    else if (a.type === "bigint") application_bigint<"3.0">(a).forEach(insert);
+    else if (a.type === "number") application_number<"3.0">(a).forEach(insert);
+    else if (a.type === "string") application_string<"3.0">(a).forEach(insert);
+
+  // ARRAY
+  for (const array of props.metadata.arrays)
+    if (array.type.recursive)
+      throw new Error(
+        "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive array type.",
+      );
+    else llm_schema_array(array).forEach(insert);
+
+  // TUPLE
+  for (const tuple of props.metadata.tuples)
+    if (tuple.type.recursive)
+      throw new Error(
+        "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive tuple type.",
+      );
+    else
+      insert(
+        llm_schema_tuple({
+          tuple,
+          attribute: props.attribute,
+        }),
+      );
+
+  // NATIVES
+  for (const native of props.metadata.natives)
+    if (AtomicPredicator.native(native)) {
+      const type: string = native.toLowerCase();
+      if (props.metadata.atomics.some((a) => a.type === type)) continue;
+      else if (type === "boolean")
+        insert(
+          application_boolean<"3.0">(
+            MetadataAtomic.create({
+              type: "boolean",
+              tags: [],
+            }),
+          )[0]!,
+        );
+      else if (type === "bigint")
+        insert(
+          application_bigint(
+            MetadataAtomic.create({
+              type: "bigint",
+              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(llm_schema_native(native));
+  if (props.metadata.sets.length) insert(llm_schema_native("Set"));
+  if (props.metadata.maps.length) insert(llm_schema_native("Map"));
+
+  // OBJECT
+  for (const object of props.metadata.objects)
+    if (object.recursive)
+      throw new Error(
+        "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive object type.",
+      );
+    else
+      insert(
+        llm_schema_object({
+          object,
+          nullable: props.metadata.nullable,
+        }),
+      );
+
+  // ALIASES
+  for (const alias of props.metadata.aliases)
+    if (alias.recursive)
+      throw new Error(
+        "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive alias type.",
+      );
+    else
+      insert(
+        llm_schema_station({
+          ...props,
+          metadata: alias.value,
+        }),
+      );
+
+  //----
+  // RETURNS
+  //----
+  if (union.length === 0 && props.blockNever === true) return null!;
+  const schema: ILlmSchema =
+    union.length === 0
+      ? { type: undefined }
+      : union.length === 1
+        ? union[0]!
+        : { oneOf: union };
+  return {
+    ...schema,
+    ...props.attribute,
+    title: props.attribute.title ?? schema.title,
+    description: props.attribute.description ?? schema.description,
+    deprecated: props.attribute.deprecated ?? schema.deprecated,
+  };
+};

package/src/programmers/internal/llm_schema_tuple.ts

@@ -0,0 +1,31 @@
+import { ILlmSchema } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+
+import { llm_schema_station } from "./llm_schema_station";
+
+/**
+ * @internal
+ */
+export const llm_schema_tuple = (props: {
+  tuple: MetadataTuple;
+  attribute: ILlmSchema.__IAttribute;
+}): ILlmSchema.IArray => ({
+  ...props.attribute,
+  type: "array",
+  items: llm_schema_station({
+    blockNever: false,
+    attribute: props.attribute,
+    metadata: props.tuple.type.elements.reduce(
+      (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
+      Metadata.initialize(),
+    ),
+  }),
+  minItems: !!props.tuple.type.elements.at(-1)?.rest
+    ? props.tuple.type.elements.length - 1
+    : props.tuple.type.elements.filter((x) => !x.optional).length,
+  maxItems: !!props.tuple.type.elements.at(-1)?.rest
+    ? undefined!
+    : props.tuple.type.elements.length,
+});

package/src/programmers/internal/stringify_regular_properties.ts

@@ -31,14 +31,14 @@ export const stringify_regular_properties = (
       (entry.meta.isRequired() === false &&
         entry.meta.nullable === false &&
         entry.meta.size() === 0) ||
-      (entry.meta.functional &&
+      (!!entry.meta.functions.length &&
         entry.meta.nullable === false &&
         entry.meta.size() === 1);
 
     if (empty === true) return;
     else if (
       entry.meta.isRequired() === false ||
-      entry.meta.functional === true ||
+      entry.meta.functions.length ||
       entry.meta.any === true
     )
       output.push(
@@ -52,7 +52,7 @@ export const stringify_regular_properties = (
                   entry.input,
                 ),
               );
-            if (entry.meta.functional || entry.meta.any)
+            if (entry.meta.functions.length || entry.meta.any)
               conditions.push(
                 ts.factory.createStrictEquality(
                   ts.factory.createStringLiteral("function"),
@@ -78,4 +78,4 @@ export const stringify_regular_properties = (
  * @internal
  */
 const sequence = (meta: Metadata): number =>
-  meta.any || !meta.isRequired() || meta.functional ? 0 : 1;
+  meta.any || !meta.isRequired() || meta.functions.length ? 0 : 1;