@nestia/core 4.4.1 → 4.4.2-dev.20241217

package/src/programmers/TypedQueryProgrammer.ts

@@ -1,108 +1,114 @@
-import ts from "typescript";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
-import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
-import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
-import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
-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 { IRequestQueryValidator } from "../options/IRequestQueryValidator";
-import { LlmValidatePredicator } from "./internal/LlmValidatePredicator";
-
-export namespace TypedQueryProgrammer {
-  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: "@nestia.core.TypedQuery",
-          errors: result.errors,
-        });
-    }
-
-    // GENERATE VALIDATION PLAN
-    const parameter =
-      (key: IRequestQueryValidator<any>["type"]) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          type: ts.Type;
-          name: string | undefined;
-          allowOptional: boolean;
-        }) => ts.Expression,
-      ) =>
-        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: {
-                  numeric: false,
-                  finite: false,
-                  functional: false,
-                },
-              },
-              modulo: props.modulo,
-              type: props.type,
-              name: undefined,
-              allowOptional: true,
-            }),
-          ),
-        ]);
-
-    // RETURNS
-    const category = props.context.options.validate;
-    if (category === "is" || category === "equals")
-      return parameter("is")(HttpIsQueryProgrammer.write);
-    else if (
-      category === "validate" ||
-      category === "validateEquals" ||
-      category === "validateClone" ||
-      category === "validatePrune"
-    )
-      return parameter("validate")(HttpValidateQueryProgrammer.write);
-    return parameter("assert")(HttpAssertQueryProgrammer.write);
-  };
-}
+import { ILlmSchema } from "@samchon/openapi";
+import ts from "typescript";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
+import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
+import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
+import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
+import { LlmSchemaProgrammer } from "typia/lib/programmers/llm/LlmSchemaProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
+
+import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
+
+export namespace TypedQueryProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // VALIDATE TYPE
+    if (props.context.options.llm) {
+      const llm: INestiaTransformOptions.ILlm<ILlmSchema.Model> =
+        props.context.options.llm;
+      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+        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: llm.model,
+                  config: {
+                    strict: llm.strict,
+                    recursive: llm.recursive,
+                  },
+                })(meta),
+              );
+              return errors;
+            },
+          },
+          collection: new MetadataCollection(),
+          type: props.type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "@nestia.core.TypedQuery",
+          errors: result.errors,
+        });
+    }
+
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestQueryValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+          allowOptional: boolean;
+        }) => ts.Expression,
+      ) =>
+        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: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              },
+              modulo: props.modulo,
+              type: props.type,
+              name: undefined,
+              allowOptional: true,
+            }),
+          ),
+        ]);
+
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsQueryProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateQueryProgrammer.write);
+    return parameter("assert")(HttpAssertQueryProgrammer.write);
+  };
+}

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,99 +1,105 @@
-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);
-  };
-}
+import { ILlmSchema } from "@samchon/openapi";
+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 { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
+
+import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
+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 => {
+    // VALIDATE TYPE
+    if (props.context.options.llm) {
+      const llm: INestiaTransformOptions.ILlm<ILlmSchema.Model> =
+        props.context.options.llm;
+      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+        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: llm.model,
+                  config: {
+                    strict: llm.strict,
+                    recursive: 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,95 +1,94 @@
-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,
-    });
-  };
-}
+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";
+
+export namespace TypedRouteProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // VALIDATE TYPE
+    if (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,
+    });
+  };
+}