@typia/transform 12.0.0-dev.20260316 → 12.0.1

package/src/features/llm/LlmApplicationTransformer.ts

@@ -1,226 +1,89 @@
-import {
-  ITypiaContext,
-  LlmApplicationProgrammer,
-  LlmMetadataFactory,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-} from "@typia/core";
-import { ILlmApplication, ILlmSchema, ValidationPipe } from "@typia/interface";
-import ts from "typescript";
-
-import { ITransformProps } from "../../ITransformProps";
-import { TransformerError } from "../../TransformerError";
-
-export namespace LlmApplicationTransformer {
-  export const transform = (props: ITransformProps): ts.Expression => {
-    // 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
-                ? (next) =>
-                    LlmApplicationProgrammer.validate({
-                      config,
-                      metadata: next.metadata,
-                      explore: next.explore,
-                      top: next.top,
-                    })
-                : undefined,
-          },
-          components: new MetadataCollection({
-            replace: MetadataCollection.replace,
-          }),
-          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 */
-  export const decompose = (
-    method: string,
-    props: ITransformProps,
-  ): {
-    application: ILlmApplication.__IPrimitive;
-    type: ts.Type;
-    node: ts.TypeNode;
-    config:
-      | Partial<
-          ILlmSchema.IConfig & {
-            equals: boolean;
-          }
-        >
-      | undefined;
-  } | null => {
-    // GET GENERIC ARGUMENT
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: `typia.llm.${method}`,
-        message: "no generic argument.",
-      });
-    const top: ts.Node = props.expression.typeArguments[0]!;
-    if (ts.isTypeNode(top) === false) return null;
-
-    // GET TYPE
-    const config:
-      | Partial<
-          ILlmSchema.IConfig & {
-            equals: boolean;
-          }
-        >
-      | undefined = LlmMetadataFactory.getConfig({
-      context: props.context,
-      method,
-      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
-                ? (next) =>
-                    LlmApplicationProgrammer.validate({
-                      config,
-                      metadata: next.metadata,
-                      explore: next.explore,
-                      top: next.top,
-                    })
-                : undefined,
-          },
-          components: new MetadataCollection({
-            replace: MetadataCollection.replace,
-          }),
-          type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: `typia.llm.${method}`,
-          errors: result.errors,
-        });
-      return result.data;
-    };
-    analyze(true);
-
-    // GENERATE LLM APPLICATION
-    return {
-      application: LlmApplicationProgrammer.writeApplication({
-        context: props.context,
-        modulo: props.modulo,
-        metadata: analyze(false),
-        config,
-        name: top.getFullText().trim(),
-      }),
-      node: top,
-      type,
-      config,
-    };
-  };
-
-  export const getConfigArgument = (props: {
-    context: ITypiaContext;
-    argument: ts.Expression;
-    equals?: boolean | undefined;
-  }) => {
-    const satisfiesTypeNode: ts.TypeNode = ts.factory.createTypeReferenceNode(
-      ts.factory.createIdentifier("Partial"),
-      [
-        ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier("Pick"),
-          [
-            ts.factory.createImportTypeNode(
-              ts.factory.createLiteralTypeNode(
-                ts.factory.createStringLiteral("typia"),
-              ),
-              undefined,
-              ts.factory.createQualifiedName(
-                ts.factory.createIdentifier("ILlmApplication"),
-                ts.factory.createIdentifier("IConfig"),
-              ),
-              undefined,
-              false,
-            ),
-            ts.factory.createUnionTypeNode([
-              ts.factory.createLiteralTypeNode(
-                ts.factory.createStringLiteral("validate"),
-              ),
-            ]),
-          ],
-        ),
-      ],
-    );
-    return ts.factory.createObjectLiteralExpression(
-      [
-        ts.factory.createSpreadAssignment(
-          ts.factory.createSatisfiesExpression(
-            props.argument,
-            satisfiesTypeNode,
-          ),
-        ),
-        ts.factory.createPropertyAssignment(
-          "equals",
-          props.equals === true
-            ? ts.factory.createTrue()
-            : ts.factory.createFalse(),
-        ),
-      ],
-      true,
-    );
-  };
-}
+import {
+  LlmApplicationProgrammer,
+  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 LlmApplicationTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // 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
+                ? (next) =>
+                    LlmApplicationProgrammer.validate({
+                      config,
+                      metadata: next.metadata,
+                      explore: next.explore,
+                      top: next.top,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          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,
+      configArgument:
+        props.expression.arguments?.[0] !== undefined
+          ? props.expression.arguments[0]
+          : undefined,
+    });
+  };
+
+}

package/src/features/llm/LlmControllerTransformer.ts

@@ -1,81 +1,100 @@
-import { LiteralFactory } from "@typia/core";
+import {
+  LlmApplicationProgrammer,
+  LlmControllerProgrammer,
+  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";
-import { LlmApplicationTransformer } from "./LlmApplicationTransformer";
 
 export namespace LlmControllerTransformer {
   export const transform = (props: ITransformProps): ts.Expression => {
-    const dec = LlmApplicationTransformer.decompose("application", props);
-    if (dec === null) return props.expression;
-    else if (props.expression.arguments[0] === undefined)
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
       throw new TransformerError({
-        code: `typia.llm.controller`,
-        message: `no identifier name.`,
+        code: "typia.llm.controller",
+        message: "no generic argument.",
       });
-    else if (props.expression.arguments[1] === undefined)
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    if (props.expression.arguments[0] === undefined)
+      throw new TransformerError({
+        code: "typia.llm.controller",
+        message: "no identifier name.",
+      });
+    if (props.expression.arguments[1] === undefined)
       throw new TransformerError({
-        code: `typia.llm.controller`,
-        message: `no executor.`,
+        code: "typia.llm.controller",
+        message: "no executor.",
       });
 
-    const typeNode: ts.ImportTypeNode = props.context.importer.type({
-      file: "typia",
-      name: "ILlmController",
-      arguments: [dec.node],
+    // GET CONFIG
+    const config:
+      | Partial<
+          ILlmSchema.IConfig & {
+            equals: boolean;
+          }
+        >
+      | undefined = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "controller",
+      node: props.expression.typeArguments[1],
     });
-    const primitiveTypeNode: ts.ImportTypeNode = props.context.importer.type({
-      file: "typia",
-      name: "ILlmApplication.__IPrimitive",
-      arguments: [dec.node],
+    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
+                ? (next) =>
+                    LlmApplicationProgrammer.validate({
+                      config,
+                      metadata: next.metadata,
+                      explore: next.explore,
+                      top: next.top,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.controller",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE LLM CONTROLLER
+    return LlmControllerProgrammer.write({
+      context: props.context,
+      modulo: props.modulo,
+      metadata: analyze(false),
+      className: top.getFullText().trim(),
+      config,
+      node: top,
+      nameArgument: props.expression.arguments[0],
+      executeArgument: props.expression.arguments[1],
+      configArgument: props.expression.arguments[2],
     });
-    const value: ts.ObjectLiteralExpression =
-      ts.factory.createObjectLiteralExpression(
-        [
-          ts.factory.createPropertyAssignment(
-            "protocol",
-            ts.factory.createStringLiteral("class"),
-          ),
-          ts.factory.createPropertyAssignment(
-            "name",
-            props.expression.arguments[0],
-          ),
-          ts.factory.createPropertyAssignment(
-            "execute",
-            props.expression.arguments[1],
-          ),
-          ts.factory.createPropertyAssignment(
-            "application",
-            ts.factory.createCallExpression(
-              props.context.importer.internal("llmApplicationFinalize"),
-              undefined,
-              [
-                ts.factory.createAsExpression(
-                  ts.factory.createSatisfiesExpression(
-                    LiteralFactory.write(dec.application),
-                    primitiveTypeNode,
-                  ),
-                  primitiveTypeNode,
-                ),
-                ...(props.expression.arguments?.[2] !== undefined
-                  ? [
-                      LlmApplicationTransformer.getConfigArgument({
-                        context: props.context,
-                        argument: props.expression.arguments[2],
-                        equals: dec.config?.equals,
-                      }),
-                    ]
-                  : []),
-              ],
-            ),
-          ),
-        ],
-        true,
-      );
-    return ts.factory.createAsExpression(
-      ts.factory.createSatisfiesExpression(value, typeNode),
-      typeNode,
-    );
   };
 }

package/src/features/llm/LlmStructuredOutputTransformer.ts

@@ -1,86 +1,86 @@
-import {
-  LlmMetadataFactory,
-  LlmStructuredOutputProgrammer,
-  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 LlmStructuredOutputTransformer {
-  export const transform = (props: ITransformProps): ts.Expression => {
-    // GET GENERIC ARGUMENT
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: "typia.llm.structuredOutput",
-        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 & { equals: boolean }> =
-      LlmMetadataFactory.getConfig({
-        context: props.context,
-        method: "structuredOutput",
-        node: props.expression.typeArguments[1],
-      }) as Partial<ILlmSchema.IConfig & { equals: boolean }>;
-
-    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
-
-    if (type.isTypeParameter())
-      throw new TransformerError({
-        code: "typia.llm.structuredOutput",
-        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
-                ? (next) =>
-                    LlmStructuredOutputProgrammer.validate({
-                      config,
-                      metadata: next.metadata,
-                      explore: next.explore,
-                    })
-                : undefined,
-          },
-          components: new MetadataCollection({
-            replace: MetadataCollection.replace,
-          }),
-          type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: "typia.llm.structuredOutput",
-          errors: result.errors,
-        });
-      return result.data;
-    };
-    analyze(true);
-
-    // GENERATE CODE
-    return LlmStructuredOutputProgrammer.write({
-      context: props.context,
-      modulo: props.modulo,
-      type,
-      metadata: analyze(false),
-      config,
-      name: (top as ts.TypeNode).getFullText().trim(),
-    });
-  };
-}
+import {
+  LlmMetadataFactory,
+  LlmStructuredOutputProgrammer,
+  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 LlmStructuredOutputTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.structuredOutput",
+        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 & { equals: boolean }> =
+      LlmMetadataFactory.getConfig({
+        context: props.context,
+        method: "structuredOutput",
+        node: props.expression.typeArguments[1],
+      }) as Partial<ILlmSchema.IConfig & { equals: boolean }>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.llm.structuredOutput",
+        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
+                ? (next) =>
+                    LlmStructuredOutputProgrammer.validate({
+                      config,
+                      metadata: next.metadata,
+                      explore: next.explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.structuredOutput",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE CODE
+    return LlmStructuredOutputProgrammer.write({
+      context: props.context,
+      modulo: props.modulo,
+      type,
+      metadata: analyze(false),
+      config,
+      name: (top as ts.TypeNode).getFullText().trim(),
+    });
+  };
+}