typia 7.0.0-dev.20241010 → 7.0.0-dev.20241011

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -11,56 +11,81 @@ import { IJsDocTagInfo } from "../../module";
 import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
 
 export namespace LlmApplicationProgrammer {
-  export const validate = (
-    metadata: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    if (explore.top === false) return LlmSchemaProgrammer.validate(metadata);
+  export const validate = () => {
+    let top: Metadata | undefined;
+    return (
+      metadata: Metadata,
+      explore: MetadataFactory.IExplore,
+    ): string[] => {
+      top ??= metadata;
+      if (explore.top === false)
+        if (
+          explore.object === top?.objects[0] &&
+          typeof explore.property === "string" &&
+          metadata.size() === 1 &&
+          metadata.nullable === false &&
+          metadata.isRequired() === true &&
+          metadata.functions.length === 1
+        )
+          return validateFunction(metadata.functions[0]!);
+        else return LlmSchemaProgrammer.validate(metadata);
 
-    const output: string[] = [];
-    const valid: boolean =
-      metadata.size() === 1 &&
-      metadata.objects.length === 1 &&
-      metadata.isRequired() === true &&
-      metadata.nullable === false;
-    if (valid === false)
-      output.push(
-        "LLM application's generic arugment must be a class/interface type.",
-      );
+      const output: string[] = [];
+      const valid: boolean =
+        metadata.size() === 1 &&
+        metadata.objects.length === 1 &&
+        metadata.isRequired() === true &&
+        metadata.nullable === false;
+      if (valid === false)
+        output.push(
+          "LLM application's generic arugment must be a class/interface type.",
+        );
 
-    const object: MetadataObject | undefined = metadata.objects[0];
-    if (object !== undefined) {
-      if (object.properties.some((p) => p.key.isSoleLiteral() === false))
-        output.push("LLM application does not allow dynamic keys.");
-      let least: boolean = false;
-      for (const p of object.properties) {
-        const value: Metadata = p.value;
-        if (value.functions.length) {
-          least ||= true;
-          if (valid === false) {
-            if (value.functions.length !== 1 || value.size() !== 1)
-              output.push(
-                "LLM application's function type does not allow union type.",
-              );
-            if (value.isRequired() === false)
-              output.push("LLM application's function type must be required.");
-            if (value.nullable === true)
-              output.push(
-                "LLM application's function type must not be nullable.",
-              );
+      const object: MetadataObject | undefined = metadata.objects[0];
+      if (object !== undefined) {
+        if (object.properties.some((p) => p.key.isSoleLiteral() === false))
+          output.push("LLM application does not allow dynamic keys.");
+        let least: boolean = false;
+        for (const p of object.properties) {
+          const value: Metadata = p.value;
+          if (value.functions.length) {
+            least ||= true;
+            if (valid === false) {
+              if (value.functions.length !== 1 || value.size() !== 1)
+                output.push(
+                  "LLM application's function type does not allow union type.",
+                );
+              if (value.isRequired() === false)
+                output.push(
+                  "LLM application's function type must be required.",
+                );
+              if (value.nullable === true)
+                output.push(
+                  "LLM application's function type must not be nullable.",
+                );
+            }
           }
         }
+        if (least === false)
+          output.push(
+            "LLM application's target type must have at least a function type.",
+          );
       }
-      if (least === false)
-        output.push(
-          "LLM application's target type must have at least a function type.",
-        );
-    }
+      return output;
+    };
+  };
+
+  const validateFunction = (func: MetadataFunction): string[] => {
+    const output: string[] = [];
+    if (func.output.size() && func.output.isRequired() === false)
+      output.push(
+        "LLM application's function return type must not be union type with undefined.",
+      );
     return output;
   };
 
   export const write = (metadata: Metadata): ILlmApplication => {
-    const errors: string[] = validate(metadata, {
+    const errors: string[] = validate()(metadata, {
       top: true,
       object: null,
       property: null,

package/src/schemas/json/IJsonApplication.ts

@@ -1,22 +1,61 @@
-import type { OpenApi, OpenApiV3 } from "@samchon/openapi";
-
-export type IJsonApplication<
-  Version extends "3.0" | "3.1" = "3.1",
-  Types = unknown[],
-> = Version extends "3.0"
-  ? IJsonApplication.IV3_0<Types>
-  : IJsonApplication.IV3_1<Types>;
-export namespace IJsonApplication {
-  export interface IV3_0<Types = unknown[]> {
-    version: "3.0";
-    schemas: OpenApiV3.IJsonSchema[];
-    components: OpenApiV3.IComponents;
-    __types?: Types | undefined;
-  }
-  export interface IV3_1<Types = unknown[]> {
-    version: "3.1";
-    components: OpenApi.IComponents;
-    schemas: OpenApi.IJsonSchema[];
-    __types?: Types | undefined;
-  }
-}
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+export interface IJsonApplication<
+  Version extends "3.0" | "3.1" = "3.1",
+  App extends any = object,
+> {
+  version: Version;
+  components: IJsonApplication.IComponents<IJsonApplication.Schema<Version>>;
+  functions: IJsonApplication.IFunction<IJsonApplication.Schema<Version>>[];
+  __application?: App | undefined;
+}
+export namespace IJsonApplication {
+  export type Schema<Version extends "3.0" | "3.1"> = Version extends "3.1"
+    ? OpenApi.IJsonSchema
+    : OpenApiV3.IJsonSchema;
+
+  export interface IComponents<
+    Schema extends
+      | OpenApi.IJsonSchema
+      | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema,
+  > {
+    schemas?: Record<string, Schema>;
+  }
+
+  export interface IFunction<
+    Schema extends
+      | OpenApi.IJsonSchema
+      | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema,
+  > {
+    async: boolean;
+    name: string;
+    parameters: IParameter<Schema>[];
+    output: IOutput<Schema> | undefined;
+    summary?: string | undefined;
+    description?: string | undefined;
+    deprecated?: boolean;
+    tags?: string[];
+  }
+
+  export interface IParameter<
+    Schema extends
+      | OpenApi.IJsonSchema
+      | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema,
+  > {
+    name: string;
+    required: boolean;
+    schema: Schema;
+    title?: string | undefined;
+    description?: string | undefined;
+  }
+
+  export interface IOutput<
+    Schema extends
+      | OpenApi.IJsonSchema
+      | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema,
+  > {
+    schema: Schema;
+    required: boolean;
+    description?: string | undefined;
+  }
+}

package/src/schemas/json/IJsonSchemaList.ts

@@ -0,0 +1,22 @@
+import type { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+export type IJsonSchemaCollection<
+  Version extends "3.0" | "3.1" = "3.1",
+  Types = unknown[],
+> = Version extends "3.0"
+  ? IJsonSchemaCollection.IV3_0<Types>
+  : IJsonSchemaCollection.IV3_1<Types>;
+export namespace IJsonSchemaCollection {
+  export interface IV3_0<Types = unknown[]> {
+    version: "3.0";
+    schemas: OpenApiV3.IJsonSchema[];
+    components: OpenApiV3.IComponents;
+    __types?: Types | undefined;
+  }
+  export interface IV3_1<Types = unknown[]> {
+    version: "3.1";
+    components: OpenApi.IComponents;
+    schemas: OpenApi.IJsonSchema[];
+    __types?: Types | undefined;
+  }
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -62,6 +62,7 @@ import { JsonCreateValidateParseTransformer } from "./features/json/JsonCreateVa
 import { JsonCreateValidateStringifyTransformer } from "./features/json/JsonCreateValidateStringifyProgrammer";
 import { JsonIsParseTransformer } from "./features/json/JsonIsParseTransformer";
 import { JsonIsStringifyTransformer } from "./features/json/JsonIsStringifyTransformer";
+import { JsonSchemasTransformer } from "./features/json/JsonSchemasTransformer";
 import { JsonStringifyTransformer } from "./features/json/JsonStringifyTransformer";
 import { JsonValidateParseTransformer } from "./features/json/JsonValidateParseTransformer";
 import { JsonValidateStringifyTransformer } from "./features/json/JsonValidateStringifyTransformer";
@@ -396,8 +397,9 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     schema: () => LlmSchemaTransformer.transform,
   },
   json: {
-    // SCHEMA
+    // METADATA
     application: () => JsonApplicationTransformer.transform,
+    schemas: () => JsonSchemasTransformer.transform,
 
     // PARSER
     isParse: () => JsonIsParseTransformer.transform,

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -15,35 +15,17 @@ import { ITransformProps } from "../../ITransformProps";
 import { TransformerError } from "../../TransformerError";
 
 export namespace JsonApplicationTransformer {
-  export const transform = (
-    props: Pick<ITransformProps, "context" | "expression">,
-  ): ts.Expression => {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
     if (!props.expression.typeArguments?.length)
       throw new TransformerError({
         code: "typia.json.application",
         message: "no generic argument.",
       });
 
-    //----
-    // GET ARGUMENTS
-    //----
-    // VALIDATE TUPLE ARGUMENTS
     const top: ts.Node = props.expression.typeArguments[0]!;
-    if (!ts.isTupleTypeNode(top)) return props.expression;
-    else if (top.elements.some((child) => !ts.isTypeNode(child)))
-      return props.expression;
+    if (ts.isTypeNode(top) === false) return props.expression;
 
-    // GET TYPES
-    const types: ts.Type[] = top.elements.map((child) =>
-      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
-    );
-    if (types.some((t) => t.isTypeParameter()))
-      throw new TransformerError({
-        code: "typia.json.application",
-        message: "non-specified generic argument(s).",
-      });
-
-    // ADDITIONAL PARAMETERS
     const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
       checker: props.context.checker,
       name: "Version",
@@ -52,46 +34,39 @@ export namespace JsonApplicationTransformer {
       default: () => "3.1",
     })(props.expression.typeArguments[1]);
 
-    //----
-    // GENERATORS
-    //----
-    // METADATA
+    // GET TYPE
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
     const collection: MetadataCollection = new MetadataCollection({
       replace: MetadataCollection.replace,
     });
-    const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
-      types.map((type) =>
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            escape: true,
-            constant: true,
-            absorb: false,
-            validate: JsonApplicationProgrammer.validate,
-          },
-          collection,
-          type,
-        }),
-      );
-
-    // REPORT BUG IF REQUIRED
-    const metadatas: Metadata[] = [];
-    const errors: MetadataFactory.IError[] = [];
-    for (const r of results) {
-      if (r.success === false) errors.push(...r.errors);
-      else metadatas.push(r.data);
-    }
-    if (errors.length)
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: false,
+          functional: true,
+          validate: JsonApplicationProgrammer.validate,
+        },
+        collection,
+        type,
+      });
+    if (result.success === false)
       throw TransformerError.from({
         code: "typia.json.application",
-        errors,
+        errors: result.errors,
       });
 
-    // APPLICATION
-    const app: IJsonApplication<any> =
-      JsonApplicationProgrammer.write(version)(metadatas);
-    return LiteralFactory.write(app);
+    // GENERATE LLM APPLICATION
+    const app: IJsonApplication<"3.0" | "3.1"> =
+      JsonApplicationProgrammer.write({
+        version,
+        metadata: result.data,
+      });
+    const literal: ts.Expression = LiteralFactory.write(app);
+    return literal;
   };
 
   const get_parameter =

package/src/transformers/features/json/JsonSchemasTransformer.ts

@@ -0,0 +1,130 @@
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IJsonSchemaCollection } from "../../../schemas/json/IJsonSchemaList";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonSchemasProgrammer } from "../../../programmers/json/JsonSchemasProgrammer";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonSchemasTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "no generic argument.",
+      });
+
+    //----
+    // GET ARGUMENTS
+    //----
+    // VALIDATE TUPLE ARGUMENTS
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (!ts.isTupleTypeNode(top)) return props.expression;
+    else if (top.elements.some((child) => !ts.isTypeNode(child)))
+      return props.expression;
+
+    // GET TYPES
+    const types: ts.Type[] = top.elements.map((child) =>
+      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
+    );
+    if (types.some((t) => t.isTypeParameter()))
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "non-specified generic argument(s).",
+      });
+
+    // ADDITIONAL PARAMETERS
+    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
+    //----
+    // GENERATORS
+    //----
+    // METADATA
+    const collection: MetadataCollection = new MetadataCollection({
+      replace: MetadataCollection.replace,
+    });
+    const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+      types.map((type) =>
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            escape: true,
+            constant: true,
+            absorb: false,
+            validate: JsonSchemasProgrammer.validate,
+          },
+          collection,
+          type,
+        }),
+      );
+
+    // REPORT BUG IF REQUIRED
+    const metadatas: Metadata[] = [];
+    const errors: MetadataFactory.IError[] = [];
+    for (const r of results) {
+      if (r.success === false) errors.push(...r.errors);
+      else metadatas.push(r.data);
+    }
+    if (errors.length)
+      throw TransformerError.from({
+        code: "typia.json.application",
+        errors,
+      });
+
+    // APPLICATION
+    const app: IJsonSchemaCollection<any> =
+      JsonSchemasProgrammer.write(version)(metadatas);
+    return LiteralFactory.write(app);
+  };
+
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/src/transformers/features/llm/LlmApplicationTransformer.ts

@@ -42,7 +42,7 @@ export namespace LlmApplicationTransformer {
           constant: true,
           absorb: false,
           functional: true,
-          validate: LlmApplicationProgrammer.validate,
+          validate: LlmApplicationProgrammer.validate(),
         },
         collection,
         type,

package/lib/internal/$httpParameterBigint.d.ts

@@ -1 +0,0 @@
-export declare const $httpParameterBigint: (value: string) => string | bigint | null;

package/lib/internal/$httpParameterBigint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$httpParameterBigint.js","sourceRoot":"","sources":["../../src/internal/$httpParameterBigint.ts"],"names":[],"mappings":";;;AAAO,IAAM,oBAAoB,GAAG,UAAC,KAAa;IAChD,OAAA,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;AAAzC,CAAyC,CAAC;AAD/B,QAAA,oBAAoB,wBACW;AAE5C,IAAM,QAAQ,GAAG,UAAC,GAAW;IAC3B,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IAAC,WAAM,CAAC;QACP,OAAO,GAAG,CAAC;IACb,CAAC;AACH,CAAC,CAAC"}

package/lib/internal/$httpParameterBoolean.d.ts

@@ -1 +0,0 @@
-export declare const $httpParameterBoolean: (value: string) => string | boolean | null;

package/lib/internal/$httpParameterBoolean.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$httpParameterBoolean.js","sourceRoot":"","sources":["../../src/internal/$httpParameterBoolean.ts"],"names":[],"mappings":";;;AAAO,IAAM,qBAAqB,GAAG,UAAC,KAAa;IACjD,OAAA,KAAK,KAAK,MAAM;QACd,CAAC,CAAC,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,GAAG;YACjC,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,GAAG;gBAClC,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC,KAAK;QACX,CAAC,CAAC,IAAI;AANR,CAMQ,CAAC;AAPE,QAAA,qBAAqB,yBAOvB"}

package/lib/internal/$httpParameterNumber.d.ts

@@ -1 +0,0 @@
-export declare const $httpParameterNumber: (value: string) => string | number | null;

package/lib/internal/$httpParameterNumber.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$httpParameterNumber.js","sourceRoot":"","sources":["../../src/internal/$httpParameterNumber.ts"],"names":[],"mappings":";;;AAAO,IAAM,oBAAoB,GAAG,UAAC,KAAa;IAChD,OAAA,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;AAAzC,CAAyC,CAAC;AAD/B,QAAA,oBAAoB,wBACW;AAE5C,IAAM,QAAQ,GAAG,UAAC,GAAW;IAC3B,IAAM,KAAK,GAAW,MAAM,CAAC,GAAG,CAAC,CAAC;IAClC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;AACpC,CAAC,CAAC"}

package/lib/internal/$httpParameterString.d.ts

@@ -1 +0,0 @@
-export declare const $httpParameterString: (value: string) => string | null;

package/lib/internal/$httpParameterString.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$httpParameterString = void 0;
-var $httpParameterString = function (value) {
-    return value !== "null" ? value : null;
-};
-exports.$httpParameterString = $httpParameterString;
-//# sourceMappingURL=$httpParameterString.js.map

package/lib/internal/$httpParameterString.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$httpParameterString.js","sourceRoot":"","sources":["../../src/internal/$httpParameterString.ts"],"names":[],"mappings":";;;AAAO,IAAM,oBAAoB,GAAG,UAAC,KAAa;IAChD,OAAA,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI;AAA/B,CAA+B,CAAC;AADrB,QAAA,oBAAoB,wBACC"}

package/src/internal/$httpParameterString.ts

@@ -1,2 +0,0 @@
-export const $httpParameterString = (value: string) =>
-  value !== "null" ? value : null;