@typia/transform 12.0.0-dev.20260225

package/src/features/llm/LlmApplicationTransformer.ts

@@ -0,0 +1,206 @@
+import {
+  ExpressionFactory,
+  ITypiaContext,
+  LiteralFactory,
+  LlmApplicationProgrammer,
+  LlmMetadataFactory,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+  StatementFactory,
+} 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 => {
+    const dec = decompose("application", props);
+    if (dec === null) return props.expression;
+
+    const literal: ts.Expression = ts.factory.createAsExpression(
+      LiteralFactory.write(dec.application),
+      props.context.importer.type({
+        file: "@samchon/openapi",
+        name: "ILlmApplication",
+        arguments: [dec.node],
+      }),
+    );
+    if (props.expression.arguments?.[0] === undefined) return literal;
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          StatementFactory.constant({
+            name: "application",
+            value: literal,
+          }),
+          ts.factory.createExpressionStatement(
+            finalize({
+              context: props.context,
+              value: ts.factory.createIdentifier("application"),
+              argument: props.expression.arguments[0]!,
+              equals: dec.config?.equals,
+            }),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("application"),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  /** @internal */
+  export const decompose = (
+    method: string,
+    props: ITransformProps,
+  ): {
+    application: ILlmApplication;
+    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
+                ? (metadata, explore) =>
+                    LlmApplicationProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataStorage({
+            replace: MetadataStorage.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.write({
+        context: props.context,
+        modulo: props.modulo,
+        metadata: analyze(false),
+        config,
+        name: top.getFullText().trim(),
+      }),
+      node: top,
+      type,
+      config,
+    };
+  };
+
+  export const finalize = (props: {
+    context: ITypiaContext;
+    value: ts.Expression;
+    argument: ts.Expression;
+    equals?: boolean;
+  }) => {
+    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("IConfig"),
+              ),
+              undefined,
+              false,
+            ),
+            ts.factory.createUnionTypeNode([
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("separate"),
+              ),
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("validate"),
+              ),
+            ]),
+          ],
+        ),
+      ],
+    );
+    return ts.factory.createCallExpression(
+      props.context.importer.internal("llmApplicationFinalize"),
+      undefined,
+      [
+        props.value,
+        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,
+        ),
+      ],
+    );
+  };
+}

package/src/features/llm/LlmControllerTransformer.ts

@@ -0,0 +1,82 @@
+import {
+  ExpressionFactory,
+  LiteralFactory,
+  StatementFactory,
+} from "@typia/core";
+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)
+      throw new TransformerError({
+        code: `typia.llm.controller`,
+        message: `no identifier name.`,
+      });
+    else if (props.expression.arguments[1] === undefined)
+      throw new TransformerError({
+        code: `typia.llm.controller`,
+        message: `no executor.`,
+      });
+
+    const property: ts.Expression = ts.factory.createAsExpression(
+      LiteralFactory.write(dec.application),
+      props.context.importer.type({
+        file: "@samchon/openapi",
+        name: "ILlmApplication",
+      }),
+    );
+    const value: ts.Expression = 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.createShorthandPropertyAssignment("application"),
+      ],
+      true,
+    );
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          StatementFactory.constant({
+            name: "application",
+            value: property,
+          }),
+          ...(props.expression.arguments?.[2] !== undefined
+            ? [
+                ts.factory.createExpressionStatement(
+                  LlmApplicationTransformer.finalize({
+                    context: props.context,
+                    value: ts.factory.createIdentifier("application"),
+                    argument: props.expression.arguments[2]!,
+                    equals: dec.config?.equals,
+                  }),
+                ),
+              ]
+            : []),
+          ts.factory.createReturnStatement(value),
+        ],
+        true,
+      ),
+      props.context.importer.type({
+        file: "@samchon/openapi",
+        name: "ILlmController",
+        arguments: [dec.node],
+      }),
+    );
+  };
+}

package/src/features/llm/LlmParametersTransformer.ts

@@ -0,0 +1,88 @@
+import {
+  LiteralFactory,
+  LlmMetadataFactory,
+  LlmParametersProgrammer,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmParametersTransformer {
+  export const transform = (
+    props: Omit<ITransformProps, "modulo">,
+  ): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.parameters",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "parameters",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    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,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmParametersProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataStorage({
+            replace: MetadataStorage.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.parameters",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE LLM SCHEMA
+    const out: ILlmSchema.IParameters = LlmParametersProgrammer.write({
+      metadata: analyze(false),
+      config,
+    });
+    return ts.factory.createAsExpression(
+      LiteralFactory.write(out),
+      props.context.importer.type({
+        file: "@samchon/openapi",
+        name: ts.factory.createQualifiedName(
+          ts.factory.createIdentifier("ILlmSchema"),
+          ts.factory.createIdentifier("IParameters"),
+        ),
+      }),
+    );
+  };
+}

package/src/features/llm/LlmSchemaTransformer.ts

@@ -0,0 +1,133 @@
+import {
+  IdentifierFactory,
+  LiteralFactory,
+  LlmMetadataFactory,
+  LlmSchemaProgrammer,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmSchemaTransformer {
+  export const transform = (
+    props: Omit<ITransformProps, "modulo">,
+  ): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.schema",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "schema",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    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,
+            constant: true,
+            escape: true,
+            validate:
+              validate === true
+                ? (metadata: MetadataSchema) =>
+                    LlmSchemaProgrammer.validate({
+                      config,
+                      metadata,
+                    })
+                : undefined,
+          },
+          components: new MetadataStorage({
+            replace: MetadataStorage.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.schema",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE LLM SCHEMA
+    const out: LlmSchemaProgrammer.IOutput = LlmSchemaProgrammer.write({
+      metadata: analyze(false),
+      config,
+    });
+    const schemaTypeNode = props.context.importer.type({
+      file: "@samchon/openapi",
+      name: "ILlmSchema",
+    });
+    const literal = ts.factory.createAsExpression(
+      LiteralFactory.write(out.schema),
+      schemaTypeNode,
+    );
+    if (Object.keys(out.$defs).length === 0) return literal;
+    return ts.factory.createCallExpression(
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "$defs",
+            ts.factory.createTypeReferenceNode("Record", [
+              ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+              schemaTypeNode,
+            ]),
+            undefined,
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createExpressionStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.assign"),
+                undefined,
+                [
+                  ts.factory.createIdentifier("$defs"),
+                  ts.factory.createAsExpression(
+                    LiteralFactory.write(out.$defs),
+                    ts.factory.createTypeReferenceNode("Record", [
+                      ts.factory.createKeywordTypeNode(
+                        ts.SyntaxKind.StringKeyword,
+                      ),
+                      schemaTypeNode,
+                    ]),
+                  ),
+                ],
+              ),
+            ),
+            ts.factory.createReturnStatement(literal),
+          ],
+          true,
+        ),
+      ),
+      undefined,
+      props.expression.arguments?.[0] !== undefined
+        ? [props.expression.arguments[0]!]
+        : [],
+    );
+  };
+}

package/src/features/misc/MiscAssertCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscAssertCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscAssertCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "misc.assertClone",
+      write: MiscAssertCloneProgrammer.write,
+    });
+}

package/src/features/misc/MiscAssertPruneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscAssertPruneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscAssertPruneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "misc.assertPrune",
+      write: MiscAssertPruneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "misc.clone",
+      write: MiscCloneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateAssertCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscAssertCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateAssertCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createAssertClone",
+      write: MiscAssertCloneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateAssertPruneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscAssertPruneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateAssertPruneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createAssertPrune",
+      write: MiscAssertPruneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createClone",
+      write: MiscCloneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateIsCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscIsCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateIsCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createIsClone",
+      write: MiscIsCloneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateIsPruneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscIsPruneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateIsPruneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createIsPrune",
+      write: MiscIsPruneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreatePruneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscPruneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreatePruneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createPrune",
+      write: MiscPruneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateValidateCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscValidateCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateValidateCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createValidateClone",
+      write: MiscValidateCloneProgrammer.write,
+    });
+}

package/src/features/misc/MiscCreateValidatePruneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscValidatePruneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscCreateValidatePruneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "misc.createValidatePrune",
+      write: MiscValidatePruneProgrammer.write,
+    });
+}

package/src/features/misc/MiscIsCloneTransformer.ts

@@ -0,0 +1,13 @@
+import { MiscIsCloneProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace MiscIsCloneTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "misc.isClone",
+      write: MiscIsCloneProgrammer.write,
+    });
+}