@nestia/core 4.4.0 → 4.4.1-dev.20241216

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,56 +1,99 @@
-import ts from "typescript";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
-import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
-import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
-import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
-
-export namespace TypedQueryRouteProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // GENERATE STRINGIFY PLAN
-    const parameter = (
-      key: string,
-      programmer: (next: {
-        context: ITypiaContext;
-        modulo: ts.LeftHandSideExpression;
-        type: ts.Type;
-      }) => ts.ArrowFunction,
-    ) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(key),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(key),
-          programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter("is", HttpIsQuerifyProgrammer.write);
-    else if (props.context.options.stringify === "validate")
-      return parameter("validate", HttpValidateQuerifyProgrammer.write);
-    else if (props.context.options.stringify === "stringify")
-      return parameter("stringify", HttpQuerifyProgrammer.write);
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter("assert", HttpAssertQuerifyProgrammer.write);
-  };
-}
+import ts from "typescript";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
+import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
+import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
+import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
+import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
+import { LlmValidatePredicator } from "./internal/LlmValidatePredicator";
+
+export namespace TypedQueryRouteProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // VALIDATE TYPE
+    if (LlmValidatePredicator.is(props.context.options.llm)) {
+      const result = MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: false,
+          constant: true,
+          absorb: true,
+          validate: (meta, explore) => {
+            const errors: string[] = HttpQueryProgrammer.validate(
+              meta,
+              explore,
+              true,
+            );
+            errors.push(
+              ...LlmSchemaProgrammer.validate({
+                model: props.context.options.llm!.model,
+                config: {
+                  strict: props.context.options.llm!.strict,
+                  recursive: props.context.options.llm!.recursive,
+                },
+              })(meta),
+            );
+            return errors;
+          },
+        },
+        collection: new MetadataCollection(),
+        type: props.type,
+      });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: props.modulo.getText(),
+          errors: result.errors,
+        });
+    }
+
+    // GENERATE STRINGIFY PLAN
+    const parameter = (
+      key: string,
+      programmer: (next: {
+        context: ITypiaContext;
+        modulo: ts.LeftHandSideExpression;
+        type: ts.Type;
+      }) => ts.ArrowFunction,
+    ) =>
+      ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier("type"),
+          ts.factory.createStringLiteral(key),
+        ),
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier(key),
+          programmer({
+            context: {
+              ...props.context,
+              options: {}, // use default option
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        ),
+      ]);
+
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter("is", HttpIsQuerifyProgrammer.write);
+    else if (props.context.options.stringify === "validate")
+      return parameter("validate", HttpValidateQuerifyProgrammer.write);
+    else if (props.context.options.stringify === "stringify")
+      return parameter("stringify", HttpQuerifyProgrammer.write);
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
+
+    // ASSERT IS DEFAULT
+    return parameter("assert", HttpAssertQuerifyProgrammer.write);
+  };
+}

package/src/programmers/TypedRouteProgrammer.ts

@@ -1,76 +1,95 @@
-import ts from "typescript";
-import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
-import { JsonIsStringifyProgrammer } from "typia/lib/programmers/json/JsonIsStringifyProgrammer";
-import { JsonStringifyProgrammer } from "typia/lib/programmers/json/JsonStringifyProgrammer";
-import { JsonValidateStringifyProgrammer } from "typia/lib/programmers/json/JsonValidateStringifyProgrammer";
-import { IProgrammerProps } from "typia/lib/transformers/IProgrammerProps";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace TypedRouteProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // GENERATE STRINGIFY PLAN
-    const parameter = (next: {
-      type: string;
-      key: string;
-      programmer: (next: IProgrammerProps) => ts.Expression;
-    }) =>
-      ts.factory.createObjectLiteralExpression([
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier("type"),
-          ts.factory.createStringLiteral(next.type),
-        ),
-        ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(next.key),
-          next.programmer({
-            context: {
-              ...props.context,
-              options: {}, // use default option
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        ),
-      ]);
-
-    // RETURNS
-    if (props.context.options.stringify === "is")
-      return parameter({
-        type: "is",
-        key: "is",
-        programmer: JsonIsStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate")
-      return parameter({
-        type: "validate",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "stringify")
-      return parameter({
-        type: "stringify",
-        key: "stringify",
-        programmer: JsonStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === "validate.log")
-      return parameter({
-        type: "validate.log",
-        key: "validate",
-        programmer: JsonValidateStringifyProgrammer.write,
-      });
-    else if (props.context.options.stringify === null)
-      return ts.factory.createNull();
-
-    // ASSERT IS DEFAULT
-    return parameter({
-      type: "assert",
-      key: "assert",
-      programmer: JsonAssertStringifyProgrammer.write,
-    });
-  };
-}
+import ts from "typescript";
+import { JsonMetadataFactory } from "typia/lib/factories/JsonMetadataFactory";
+import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
+import { JsonIsStringifyProgrammer } from "typia/lib/programmers/json/JsonIsStringifyProgrammer";
+import { JsonStringifyProgrammer } from "typia/lib/programmers/json/JsonStringifyProgrammer";
+import { JsonValidateStringifyProgrammer } from "typia/lib/programmers/json/JsonValidateStringifyProgrammer";
+import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
+import { IProgrammerProps } from "typia/lib/transformers/IProgrammerProps";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { LlmValidatePredicator } from "./internal/LlmValidatePredicator";
+
+export namespace TypedRouteProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // VALIDATE TYPE
+    if (LlmValidatePredicator.is(props.context.options.llm))
+      JsonMetadataFactory.analyze({
+        method: "@nestia.core.TypedBody",
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        type: props.type,
+        validate: LlmSchemaProgrammer.validate({
+          model: props.context.options.llm.model,
+          config: {
+            strict: props.context.options.llm.strict,
+            recursive: props.context.options.llm.recursive,
+          },
+        }),
+      });
+
+    // GENERATE STRINGIFY PLAN
+    const parameter = (next: {
+      type: string;
+      key: string;
+      programmer: (next: IProgrammerProps) => ts.Expression;
+    }) =>
+      ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier("type"),
+          ts.factory.createStringLiteral(next.type),
+        ),
+        ts.factory.createPropertyAssignment(
+          ts.factory.createIdentifier(next.key),
+          next.programmer({
+            context: {
+              ...props.context,
+              options: {}, // use default option
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        ),
+      ]);
+
+    // RETURNS
+    if (props.context.options.stringify === "is")
+      return parameter({
+        type: "is",
+        key: "is",
+        programmer: JsonIsStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate")
+      return parameter({
+        type: "validate",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "stringify")
+      return parameter({
+        type: "stringify",
+        key: "stringify",
+        programmer: JsonStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === "validate.log")
+      return parameter({
+        type: "validate.log",
+        key: "validate",
+        programmer: JsonValidateStringifyProgrammer.write,
+      });
+    else if (props.context.options.stringify === null)
+      return ts.factory.createNull();
+
+    // ASSERT IS DEFAULT
+    return parameter({
+      type: "assert",
+      key: "assert",
+      programmer: JsonAssertStringifyProgrammer.write,
+    });
+  };
+}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpAssertQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "assert",
-          value: AssertProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            config: {
-              equals: false,
-              guard: false,
-            },
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("stringify"),
-            undefined,
-            [
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("assert"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            ],
-          ),
-        ),
-      ]),
-    );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpAssertQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "assert",
+          value: AssertProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            config: {
+              equals: false,
+              guard: false,
+            },
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("stringify"),
+            undefined,
+            [
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("assert"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            ],
+          ),
+        ),
+      ]),
+    );
+}

package/src/programmers/http/HttpIsQuerifyProgrammer.ts

@@ -1,75 +1,75 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-
-export namespace HttpIsQuerifyProgrammer {
-  export const write = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      undefined,
-      undefined,
-      ts.factory.createBlock([
-        StatementFactory.constant({
-          name: "is",
-          value: IsProgrammer.write({
-            config: {
-              equals: false,
-            },
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-            name: undefined,
-          }),
-        }),
-        StatementFactory.constant({
-          name: "stringify",
-          value: HttpQuerifyProgrammer.write({
-            context: {
-              ...props.context,
-              options: {
-                ...props.context.options,
-                functional: false,
-                numeric: false,
-              },
-            },
-            modulo: props.modulo,
-            type: props.type,
-          }),
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createConditionalExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("is"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            undefined,
-            ts.factory.createNull(),
-          ),
-        ),
-      ]),
-    );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpIsQuerifyProgrammer {
+  export const write = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      undefined,
+      undefined,
+      ts.factory.createBlock([
+        StatementFactory.constant({
+          name: "is",
+          value: IsProgrammer.write({
+            config: {
+              equals: false,
+            },
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+            name: undefined,
+          }),
+        }),
+        StatementFactory.constant({
+          name: "stringify",
+          value: HttpQuerifyProgrammer.write({
+            context: {
+              ...props.context,
+              options: {
+                ...props.context.options,
+                functional: false,
+                numeric: false,
+              },
+            },
+            modulo: props.modulo,
+            type: props.type,
+          }),
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("is"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("stringify"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ]),
+    );
+}