fix(core): LLM custom validation was not working. (#1793)

* fix(core): LLM custom validation was not working.

* refactoring

* add test case

Author: samchon

packages/core/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -52,6 +52,7 @@ export namespace LlmApplicationProgrammer {
       }
     >;
     name?: string;
+    configArgument?: ts.Expression;
   }
 
   export const write = (props: IWriteProps): ts.CallExpression => {
@@ -82,17 +83,7 @@ export namespace LlmApplicationProgrammer {
           ),
           typeNode,
         ),
-        ts.factory.createObjectLiteralExpression(
-          [
-            ts.factory.createPropertyAssignment(
-              "equals",
-              props.config?.equals === true
-                ? ts.factory.createTrue()
-                : ts.factory.createFalse(),
-            ),
-          ],
-          false,
-        ),
+        ...(props.configArgument ? [props.configArgument] : []),
       ],
     );
   };

packages/core/src/programmers/llm/LlmControllerProgrammer.ts

@@ -0,0 +1,59 @@
+import { ILlmSchema } from "@typia/interface";
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+import { LlmApplicationProgrammer } from "./LlmApplicationProgrammer";
+
+export namespace LlmControllerProgrammer {
+  export interface IWriteProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    metadata: MetadataSchema;
+    config?: Partial<
+      ILlmSchema.IConfig & {
+        equals: boolean;
+      }
+    >;
+    className?: string;
+    node: ts.TypeNode;
+    nameArgument: ts.Expression;
+    executeArgument: ts.Expression;
+    configArgument?: ts.Expression;
+  }
+
+  export const write = (props: IWriteProps): ts.Expression => {
+    const typeNode: ts.ImportTypeNode = props.context.importer.type({
+      file: "typia",
+      name: "ILlmController",
+      arguments: [props.node],
+    });
+    const value: ts.ObjectLiteralExpression =
+      ts.factory.createObjectLiteralExpression(
+        [
+          ts.factory.createPropertyAssignment(
+            "protocol",
+            ts.factory.createStringLiteral("class"),
+          ),
+          ts.factory.createPropertyAssignment("name", props.nameArgument),
+          ts.factory.createPropertyAssignment("execute", props.executeArgument),
+          ts.factory.createPropertyAssignment(
+            "application",
+            LlmApplicationProgrammer.write({
+              context: props.context,
+              modulo: props.modulo,
+              metadata: props.metadata,
+              config: props.config,
+              name: props.className,
+              configArgument: props.configArgument,
+            }),
+          ),
+        ],
+        true,
+      );
+    return ts.factory.createAsExpression(
+      ts.factory.createSatisfiesExpression(value, typeNode),
+      typeNode,
+    );
+  };
+}

packages/core/src/programmers/llm/index.ts

@@ -1,4 +1,5 @@
 export * from "./LlmApplicationProgrammer";
+export * from "./LlmControllerProgrammer";
 export * from "./LlmCoerceProgrammer";
 export * from "./LlmMetadataFactory";
 export * from "./LlmParametersProgrammer";

packages/transform/src/features/llm/LlmApplicationTransformer.ts

@@ -1,12 +1,11 @@
 import {
-  ITypiaContext,
   LlmApplicationProgrammer,
   LlmMetadataFactory,
   MetadataCollection,
   MetadataFactory,
   MetadataSchema,
 } from "@typia/core";
-import { ILlmApplication, ILlmSchema, ValidationPipe } from "@typia/interface";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
 import ts from "typescript";
 
 import { ITransformProps } from "../../ITransformProps";
@@ -80,147 +79,11 @@ export namespace LlmApplicationTransformer {
       metadata: analyze(false),
       name: top.getFullText().trim(),
       config,
+      configArgument:
+        props.expression.arguments?.[0] !== undefined
+          ? props.expression.arguments[0]
+          : undefined,
     });
   };
 
-  /** @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,
-    );
-  };
 }