@typia/transform 12.0.0-dev.20260307 → 12.0.0-dev.20260309

package/src/features/json/JsonApplicationTransformer.ts

@@ -1,11 +1,10 @@
 import {
   JsonApplicationProgrammer,
-  LiteralFactory,
   MetadataCollection,
   MetadataFactory,
   MetadataSchema,
 } from "@typia/core";
-import { IJsonSchemaApplication, ValidationPipe } from "@typia/interface";
+import { ValidationPipe } from "@typia/interface";
 import ts from "typescript";
 
 import { ITransformProps } from "../../ITransformProps";
@@ -56,14 +55,12 @@ export namespace JsonApplicationTransformer {
         errors: result.errors,
       });
 
-    // GENERATE LLM APPLICATION
-    const app: IJsonSchemaApplication<"3.0" | "3.1"> =
-      JsonApplicationProgrammer.write({
-        version,
-        metadata: result.data,
-      });
-    const literal: ts.Expression = LiteralFactory.write(app);
-    return literal;
+    // GENERATE JSON APPLICATION
+    return JsonApplicationProgrammer.write({
+      context: props.context,
+      version,
+      metadata: result.data,
+    });
   };
 
   const get_parameter =

package/src/features/json/JsonSchemaTransformer.ts

@@ -1,12 +1,11 @@
 import {
   JsonSchemaProgrammer,
   JsonSchemasProgrammer,
-  LiteralFactory,
   MetadataCollection,
   MetadataFactory,
   MetadataSchema,
 } from "@typia/core";
-import { IJsonSchemaUnit, ValidationPipe } from "@typia/interface";
+import { ValidationPipe } from "@typia/interface";
 import ts from "typescript";
 
 import { ITransformProps } from "../../ITransformProps";
@@ -78,22 +77,11 @@ export namespace JsonSchemaTransformer {
     analyze(true);
 
     // APPLICATION
-    const app: IJsonSchemaUnit<any> = JsonSchemaProgrammer.write({
+    return JsonSchemaProgrammer.write({
+      context: props.context,
       version,
       metadata: analyze(false),
     });
-    return ts.factory.createAsExpression(
-      LiteralFactory.write(app),
-      props.context.importer.type({
-        file: "typia",
-        name: "IJsonSchemaUnit",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(version),
-          ),
-        ],
-      }),
-    );
   };
 
   const getParameter =

package/src/features/json/JsonSchemasTransformer.ts

@@ -1,11 +1,10 @@
 import {
   JsonSchemasProgrammer,
-  LiteralFactory,
   MetadataCollection,
   MetadataFactory,
   MetadataSchema,
 } from "@typia/core";
-import { IJsonSchemaCollection, ValidationPipe } from "@typia/interface";
+import { ValidationPipe } from "@typia/interface";
 import ts from "typescript";
 
 import { ITransformProps } from "../../ITransformProps";
@@ -88,22 +87,11 @@ export namespace JsonSchemasTransformer {
     analyze(true);
 
     // APPLICATION
-    const collection: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
+    return JsonSchemasProgrammer.write({
+      context: props.context,
       version,
       metadatas: analyze(false),
     });
-    return ts.factory.createAsExpression(
-      LiteralFactory.write(collection),
-      props.context.importer.type({
-        file: "typia",
-        name: "IJsonSchemaCollection",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(version),
-          ),
-        ],
-      }),
-    );
   };
 
   const getParameter =

package/src/features/llm/LlmApplicationTransformer.ts

@@ -1,6 +1,5 @@
 import {
   ITypiaContext,
-  LiteralFactory,
   LlmApplicationProgrammer,
   LlmMetadataFactory,
   MetadataCollection,
@@ -15,31 +14,72 @@ import { TransformerError } from "../../TransformerError";
 
 export namespace LlmApplicationTransformer {
   export const transform = (props: ITransformProps): ts.Expression => {
-    const dec = decompose("application", props);
-    if (dec === null) return props.expression;
-    return ts.factory.createCallExpression(
-      props.context.importer.internal("llmApplicationFinalize"),
-      [dec.node],
-      [
-        ts.factory.createSatisfiesExpression(
-          LiteralFactory.write(dec.application),
-          props.context.importer.type({
-            file: "typia",
-            name: "ILlmApplication.__IPrimitive",
-            arguments: [dec.node],
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.application",
+        message: "no generic argument.",
+      });
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET CONFIG
+    const config:
+      | Partial<
+          ILlmSchema.IConfig & {
+            equals: boolean;
+          }
+        >
+      | undefined = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "application",
+      node: props.expression.typeArguments[1],
+    });
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            functional: true,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmApplicationProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
           }),
-        ),
-        ...(props.expression.arguments?.[0] !== undefined
-          ? [
-              getConfigArgument({
-                context: props.context,
-                argument: props.expression.arguments[0],
-                equals: dec.config?.equals,
-              }),
-            ]
-          : []),
-      ],
-    );
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.application",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE LLM APPLICATION
+    return LlmApplicationProgrammer.write({
+      context: props.context,
+      modulo: props.modulo,
+      metadata: analyze(false),
+      name: top.getFullText().trim(),
+      config,
+    });
   };
 
   /** @internal */
@@ -118,7 +158,7 @@ export namespace LlmApplicationTransformer {
 
     // GENERATE LLM APPLICATION
     return {
-      application: LlmApplicationProgrammer.write({
+      application: LlmApplicationProgrammer.writeApplication({
         context: props.context,
         modulo: props.modulo,
         metadata: analyze(false),

package/src/features/llm/LlmCoerceTransformer.ts

@@ -0,0 +1,95 @@
+import {
+  LlmCoerceProgrammer,
+  LlmMetadataFactory,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmCoerceTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK PARAMETER
+    if (props.expression.arguments.length === 0)
+      throw new TransformerError({
+        code: "typia.llm.coerce",
+        message: "no input value.",
+      });
+
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.coerce",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE AND CONFIG
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "coerce",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.llm.coerce",
+        message: "non-specified generic argument.",
+      });
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmCoerceProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.coerce",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE CODE
+    return ts.factory.createCallExpression(
+      LlmCoerceProgrammer.write({
+        context: props.context,
+        modulo: props.modulo,
+        metadata: analyze(false),
+        name: (top as ts.TypeNode).getFullText().trim(),
+        config,
+      }),
+      undefined,
+      props.expression.arguments,
+    );
+  };
+}

package/src/features/llm/LlmControllerTransformer.ts

@@ -20,6 +20,16 @@ export namespace LlmControllerTransformer {
         message: `no executor.`,
       });
 
+    const typeNode: ts.ImportTypeNode = props.context.importer.type({
+      file: "typia",
+      name: "ILlmController",
+      arguments: [dec.node],
+    });
+    const primitiveTypeNode: ts.ImportTypeNode = props.context.importer.type({
+      file: "typia",
+      name: "ILlmApplication.__IPrimitive",
+      arguments: [dec.node],
+    });
     const value: ts.ObjectLiteralExpression =
       ts.factory.createObjectLiteralExpression(
         [
@@ -41,13 +51,12 @@ export namespace LlmControllerTransformer {
               props.context.importer.internal("llmApplicationFinalize"),
               undefined,
               [
-                ts.factory.createSatisfiesExpression(
-                  LiteralFactory.write(dec.application),
-                  props.context.importer.type({
-                    file: "typia",
-                    name: "ILlmApplication.__IPrimitive",
-                    arguments: [dec.node],
-                  }),
+                ts.factory.createAsExpression(
+                  ts.factory.createSatisfiesExpression(
+                    LiteralFactory.write(dec.application),
+                    primitiveTypeNode,
+                  ),
+                  primitiveTypeNode,
                 ),
                 ...(props.expression.arguments?.[2] !== undefined
                   ? [
@@ -64,13 +73,9 @@ export namespace LlmControllerTransformer {
         ],
         true,
       );
-    return ts.factory.createSatisfiesExpression(
-      value,
-      props.context.importer.type({
-        file: "typia",
-        name: "ILlmController",
-        arguments: [dec.node],
-      }),
+    return ts.factory.createAsExpression(
+      ts.factory.createSatisfiesExpression(value, typeNode),
+      typeNode,
     );
   };
 }

package/src/features/llm/LlmCreateCoerceTransformer.ts

@@ -0,0 +1,84 @@
+import {
+  LlmCoerceProgrammer,
+  LlmMetadataFactory,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmCreateCoerceTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.createCoerce",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE AND CONFIG
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "createCoerce",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.llm.createCoerce",
+        message: "non-specified generic argument.",
+      });
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmCoerceProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.createCoerce",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE CODE (factory returns the function directly)
+    return LlmCoerceProgrammer.write({
+      context: props.context,
+      modulo: props.modulo,
+      metadata: analyze(false),
+      name: (top as ts.TypeNode).getFullText().trim(),
+      config,
+    });
+  };
+}

package/src/features/llm/LlmCreateParseTransformer.ts

@@ -0,0 +1,84 @@
+import {
+  LlmMetadataFactory,
+  LlmParseProgrammer,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmCreateParseTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.createParse",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE AND CONFIG
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "createParse",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.llm.createParse",
+        message: "non-specified generic argument.",
+      });
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmParseProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.createParse",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE CODE (factory returns the function directly)
+    return LlmParseProgrammer.write({
+      context: props.context,
+      modulo: props.modulo,
+      metadata: analyze(false),
+      name: (top as ts.TypeNode).getFullText().trim(),
+      config,
+    });
+  };
+}

package/src/features/llm/LlmParametersTransformer.ts

@@ -1,5 +1,4 @@
 import {
-  LiteralFactory,
   LlmMetadataFactory,
   LlmParametersProgrammer,
   MetadataCollection,
@@ -13,9 +12,7 @@ import { ITransformProps } from "../../ITransformProps";
 import { TransformerError } from "../../TransformerError";
 
 export namespace LlmParametersTransformer {
-  export const transform = (
-    props: Omit<ITransformProps, "modulo">,
-  ): ts.Expression => {
+  export const transform = (props: ITransformProps): ts.Expression => {
     // GET GENERIC ARGUMENT
     if (!props.expression.typeArguments?.length)
       throw new TransformerError({
@@ -69,20 +66,11 @@ export namespace LlmParametersTransformer {
     };
     analyze(true);
 
-    // GENERATE LLM SCHEMA
-    const out: ILlmSchema.IParameters = LlmParametersProgrammer.write({
+    // GENERATE LLM PARAMETERS SCHEMA
+    return LlmParametersProgrammer.write({
+      context: props.context,
       metadata: analyze(false),
       config,
     });
-    return ts.factory.createSatisfiesExpression(
-      LiteralFactory.write(out),
-      props.context.importer.type({
-        file: "typia",
-        name: ts.factory.createQualifiedName(
-          ts.factory.createIdentifier("ILlmSchema"),
-          ts.factory.createIdentifier("IParameters"),
-        ),
-      }),
-    );
   };
 }

package/src/features/llm/LlmParseTransformer.ts

@@ -0,0 +1,95 @@
+import {
+  LlmMetadataFactory,
+  LlmParseProgrammer,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmParseTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK PARAMETER
+    if (props.expression.arguments.length === 0)
+      throw new TransformerError({
+        code: "typia.llm.parse",
+        message: "no input value.",
+      });
+
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.parse",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE AND CONFIG
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "parse",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.llm.parse",
+        message: "non-specified generic argument.",
+      });
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmParseProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.parse",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE CODE
+    return ts.factory.createCallExpression(
+      LlmParseProgrammer.write({
+        context: props.context,
+        modulo: props.modulo,
+        metadata: analyze(false),
+        name: (top as ts.TypeNode).getFullText().trim(),
+        config,
+      }),
+      undefined,
+      props.expression.arguments,
+    );
+  };
+}