typia 9.5.0 → 9.6.0

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -117,35 +117,37 @@ export namespace LlmApplicationProgrammer {
     const prefix: string = `LLM application's function (${JSON.stringify(name)})`;
     if (func.output.size() && func.output.isRequired() === false)
       output.push(
-        `${prefix}'s return type must not be union type with undefined.`,
+        `${prefix} return type cannot be optional (union with undefined).`,
       );
     if (/^[0-9]/.test(name[0] ?? "") === true)
-      output.push(`${prefix} name must not start with a number.`);
+      output.push(`${prefix} name cannot start with a number.`);
     if (/^[a-zA-Z0-9_-]+$/.test(name) === false)
       output.push(
-        `${prefix} name must be alphanumeric with underscore or hyphen.`,
+        `${prefix} name must contain only alphanumeric characters, underscores, or hyphens.`,
       );
     if (name.length > 64)
-      output.push(`${prefix} name must not exceed 64 characters.`);
+      output.push(`${prefix} name cannot exceed 64 characters.`);
     if (func.parameters.length !== 0 && func.parameters.length !== 1)
-      output.push(`${prefix} must have a single parameter.`);
+      output.push(
+        `${prefix} must have exactly one parameter or no parameters.`,
+      );
     if (func.parameters.length !== 0) {
       const type: Metadata = func.parameters[0]!.type;
       if (type.size() !== 1 || type.objects.length !== 1)
-        output.push(`${prefix}'s parameter must be an object type.`);
+        output.push(`${prefix} parameter must be a single object type.`);
       else {
         if (
           type.objects[0]!.type.properties.some(
             (p) => p.key.isSoleLiteral() === false,
           )
         )
-          output.push(`${prefix}'s parameter must not have dynamic keys.`);
+          output.push(`${prefix} parameter cannot have dynamic property keys.`);
         if (type.isRequired() === false)
           output.push(
-            `${prefix}'s parameter must not be union type with undefined.`,
+            `${prefix} parameter cannot be optional (union with undefined).`,
           );
         if (type.nullable === true)
-          output.push(`${prefix}'s parameter must not be nullable.`);
+          output.push(`${prefix} parameter cannot be nullable.`);
       }
     }
     return output;
@@ -156,7 +158,11 @@ export namespace LlmApplicationProgrammer {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     metadata: Metadata;
-    config?: Partial<ILlmSchema.ModelConfig[Model]>;
+    config?: Partial<
+      ILlmSchema.ModelConfig[Model] & {
+        equals: boolean;
+      }
+    >;
     name?: string;
   }): ILlmApplication<Model> => {
     const metadata: Metadata = Metadata.unalias(props.metadata);
@@ -197,6 +203,7 @@ export namespace LlmApplicationProgrammer {
           context: props.context,
           modulo: props.modulo,
           className: props.name,
+          config: props.config,
           components: application.components,
           function: func,
           errors: errorMessages,
@@ -228,6 +235,13 @@ export namespace LlmApplicationProgrammer {
     parameter: MetadataParameter | null;
     errors: string[];
     className?: string;
+    config:
+      | Partial<
+          ILlmSchema.ModelConfig[Model] & {
+            equals: boolean;
+          }
+        >
+      | undefined;
   }): ILlmFunction<Model> | null => {
     const parameters: ILlmSchema.ModelParameters[Model] | null =
       writeParameters({
@@ -272,12 +286,13 @@ export namespace LlmApplicationProgrammer {
       })(),
       deprecated: props.function.deprecated,
       tags: props.function.tags,
-      validate: writeValidadtor({
+      validate: writeValidator({
         context: props.context,
         modulo: props.modulo,
         parameter: props.parameter,
         name: props.function.name,
         className: props.className,
+        equals: props.config?.equals ?? false,
       }),
     };
   };
@@ -346,11 +361,12 @@ export namespace LlmApplicationProgrammer {
     return result.value;
   };
 
-  const writeValidadtor = (props: {
+  const writeValidator = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     parameter: MetadataParameter | null;
     name: string;
+    equals: boolean;
     className?: string;
   }): ((props: unknown) => IValidation<unknown>) => {
     if (props.parameter === null)
@@ -360,7 +376,7 @@ export namespace LlmApplicationProgrammer {
           TypeFactory.keyword("any"),
         ),
         config: {
-          equals: false,
+          equals: props.equals,
         },
         name: undefined,
       }) as any;
@@ -375,7 +391,7 @@ export namespace LlmApplicationProgrammer {
       ...props,
       type: props.parameter.tsType!,
       config: {
-        equals: false,
+        equals: props.equals,
       },
       name: props.className
         ? `Parameters<${props.className}[${JSON.stringify(props.name)}]>[0]`

package/src/programmers/llm/LlmModelPredicator.ts

@@ -19,7 +19,13 @@ export namespace LlmModelPredicator {
     method: string;
     model: ILlmSchema.Model;
     node: ts.TypeNode | undefined;
-  }): Partial<ILlmSchema.ModelConfig[ILlmSchema.Model]> | undefined => {
+  }):
+    | Partial<
+        ILlmSchema.ModelConfig[ILlmSchema.Model] & {
+          equals: boolean;
+        }
+      >
+    | undefined => {
     if (props.node === undefined) return undefined;
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(props.node);
     const collection: MetadataCollection = new MetadataCollection();

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

@@ -15,6 +15,7 @@ import { LlmModelPredicator } from "../../../programmers/llm/LlmModelPredicator"
 import { ValidationPipe } from "../../../typings/ValidationPipe";
 
 import { ITransformProps } from "../../ITransformProps";
+import { ITypiaContext } from "../../ITypiaContext";
 import { TransformerError } from "../../TransformerError";
 
 export namespace LlmApplicationTransformer {
@@ -43,14 +44,13 @@ export namespace LlmApplicationTransformer {
             value: literal,
           }),
           ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-              props.context.importer.internal("llmApplicationFinalize"),
-              undefined,
-              [
-                ts.factory.createIdentifier("application"),
-                props.expression.arguments[0],
-              ],
-            ),
+            finalize({
+              context: props.context,
+              value: ts.factory.createIdentifier("application"),
+              argument: props.expression.arguments[0]!,
+              equals: dec.config?.equals,
+              model: dec.application.model,
+            }),
           ),
           ts.factory.createReturnStatement(
             ts.factory.createIdentifier("application"),
@@ -71,6 +71,13 @@ export namespace LlmApplicationTransformer {
     application: ILlmApplication<ILlmSchema.Model>;
     type: ts.Type;
     node: ts.TypeNode;
+    config:
+      | Partial<
+          ILlmSchema.IConfig & {
+            equals: boolean;
+          }
+        >
+      | undefined;
   } | null => {
     // GET GENERIC ARGUMENT
     if (!props.expression.typeArguments?.length)
@@ -87,12 +94,18 @@ export namespace LlmApplicationTransformer {
       method,
       node: props.expression.typeArguments[1],
     });
-    const config: Partial<ILlmSchema.IConfig> = LlmModelPredicator.getConfig({
+    const config:
+      | Partial<
+          ILlmSchema.IConfig & {
+            equals: boolean;
+          }
+        >
+      | undefined = LlmModelPredicator.getConfig({
       context: props.context,
       method,
       model,
       node: props.expression.typeArguments[2],
-    }) as Partial<ILlmSchema.IConfig>;
+    });
     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
 
     // VALIDATE TYPE
@@ -140,6 +153,78 @@ export namespace LlmApplicationTransformer {
       }),
       node: top,
       type,
+      config,
     };
   };
+
+  export const finalize = (props: {
+    context: ITypiaContext;
+    value: ts.Expression;
+    argument: ts.Expression;
+    equals?: boolean;
+    model: ILlmSchema.Model;
+  }) => {
+    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("@samchon/openapi"),
+              ),
+              undefined,
+              ts.factory.createQualifiedName(
+                ts.factory.createIdentifier("ILlmApplication"),
+                ts.factory.createIdentifier("IOptions"),
+              ),
+              [
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral(props.model),
+                ),
+              ],
+              false,
+            ),
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("separate"),
+            ),
+          ],
+        ),
+      ],
+    );
+    return ts.factory.createCallExpression(
+      props.context.importer.internal("llmApplicationFinalize"),
+      undefined,
+      [
+        props.value,
+        ts.factory.createObjectLiteralExpression(
+          [
+            ts.factory.createPropertyAssignment(
+              "separate",
+              ts.factory.createPropertyAccessChain(
+                ts.factory.createSatisfiesExpression(
+                  props.argument,
+                  satisfiesTypeNode,
+                ),
+                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                "separate",
+              ),
+            ),
+            ...(typeof props.equals === "boolean"
+              ? [
+                  ts.factory.createPropertyAssignment(
+                    "equals",
+                    props.equals === true
+                      ? ts.factory.createTrue()
+                      : ts.factory.createFalse(),
+                  ),
+                ]
+              : []),
+          ],
+          true,
+        ),
+      ],
+    );
+  };
 }

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

@@ -63,14 +63,13 @@ export namespace LlmControllerTransformer {
           ...(props.expression.arguments?.[2] !== undefined
             ? [
                 ts.factory.createExpressionStatement(
-                  ts.factory.createCallExpression(
-                    props.context.importer.internal("llmApplicationFinalize"),
-                    undefined,
-                    [
-                      ts.factory.createIdentifier("application"),
-                      props.expression.arguments[2],
-                    ],
-                  ),
+                  LlmApplicationTransformer.finalize({
+                    context: props.context,
+                    value: ts.factory.createIdentifier("application"),
+                    argument: props.expression.arguments[2]!,
+                    equals: dec.config?.equals,
+                    model: dec.application.model,
+                  }),
                 ),
               ]
             : []),