@nestia/core 7.0.0-dev.20250607 → 7.0.0

package/src/programmers/TypedHeadersProgrammer.ts

@@ -1,63 +1,63 @@
-import ts from "typescript";
-import { HttpAssertHeadersProgrammer } from "typia/lib/programmers/http/HttpAssertHeadersProgrammer";
-import { HttpIsHeadersProgrammer } from "typia/lib/programmers/http/HttpIsHeadersProgrammer";
-import { HttpValidateHeadersProgrammer } from "typia/lib/programmers/http/HttpValidateHeadersProgrammer";
-import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { IRequestHeadersValidator } from "../options/IRequestHeadersValidator";
-
-export namespace TypedHeadersProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.Expression => {
-    // GENERATE VALIDATION PLAN
-    const parameter =
-      (key: IRequestHeadersValidator<any>["type"]) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          type: ts.Type;
-          name: string | undefined;
-        }) => 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,
-            }),
-          ),
-        ]);
-
-    // RETURNS
-    const category = props.context.options.validate;
-    if (category === "is" || category === "equals")
-      return parameter("is")(HttpIsHeadersProgrammer.write);
-    else if (
-      category === "validate" ||
-      category === "validateEquals" ||
-      category === "validateClone" ||
-      category === "validatePrune"
-    )
-      return parameter("validate")(HttpValidateHeadersProgrammer.write);
-    return parameter("assert")(HttpAssertHeadersProgrammer.write);
-  };
-}
+import ts from "typescript";
+import { HttpAssertHeadersProgrammer } from "typia/lib/programmers/http/HttpAssertHeadersProgrammer";
+import { HttpIsHeadersProgrammer } from "typia/lib/programmers/http/HttpIsHeadersProgrammer";
+import { HttpValidateHeadersProgrammer } from "typia/lib/programmers/http/HttpValidateHeadersProgrammer";
+import { ITypiaContext } from "typia/lib/transformers/ITypiaContext";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { IRequestHeadersValidator } from "../options/IRequestHeadersValidator";
+
+export namespace TypedHeadersProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.Expression => {
+    // GENERATE VALIDATION PLAN
+    const parameter =
+      (key: IRequestHeadersValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => 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,
+            }),
+          ),
+        ]);
+
+    // RETURNS
+    const category = props.context.options.validate;
+    if (category === "is" || category === "equals")
+      return parameter("is")(HttpIsHeadersProgrammer.write);
+    else if (
+      category === "validate" ||
+      category === "validateEquals" ||
+      category === "validateClone" ||
+      category === "validatePrune"
+    )
+      return parameter("validate")(HttpValidateHeadersProgrammer.write);
+    return parameter("assert")(HttpAssertHeadersProgrammer.write);
+  };
+}

package/src/programmers/TypedParamProgrammer.ts

@@ -1,33 +1,33 @@
-import ts from "typescript";
-import { HttpParameterProgrammer } from "typia/lib/programmers/http/HttpParameterProgrammer";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace TypedParamProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    arguments: readonly ts.Expression[];
-    type: ts.Type;
-  }): readonly ts.Expression[] => {
-    // ALREADY BEING TRANSFORMED
-    if (props.arguments.length !== 1) return props.arguments;
-    return [
-      props.arguments[0],
-      HttpParameterProgrammer.write({
-        context: {
-          ...props.context,
-          options: {
-            numeric: true,
-          },
-        },
-        modulo: props.modulo,
-        type: props.type,
-        name: undefined,
-      }),
-      ...(props.context.options?.validate?.startsWith("validate")
-        ? [ts.factory.createTrue()]
-        : []),
-    ];
-  };
-}
+import ts from "typescript";
+import { HttpParameterProgrammer } from "typia/lib/programmers/http/HttpParameterProgrammer";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+
+export namespace TypedParamProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    arguments: readonly ts.Expression[];
+    type: ts.Type;
+  }): readonly ts.Expression[] => {
+    // ALREADY BEING TRANSFORMED
+    if (props.arguments.length !== 1) return props.arguments;
+    return [
+      props.arguments[0],
+      HttpParameterProgrammer.write({
+        context: {
+          ...props.context,
+          options: {
+            numeric: true,
+          },
+        },
+        modulo: props.modulo,
+        type: props.type,
+        name: undefined,
+      }),
+      ...(props.context.options?.validate?.startsWith("validate")
+        ? [ts.factory.createTrue()]
+        : []),
+    ];
+  };
+}

package/src/programmers/TypedQueryBodyProgrammer.ts

@@ -1,112 +1,112 @@
-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 TypedQueryBodyProgrammer {
-  export const generate = (props: {
-    context: INestiaTransformContext;
-    modulo: ts.LeftHandSideExpression;
-    type: ts.Type;
-  }): ts.ObjectLiteralExpression => {
-    // 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 VALIDATION PLAN
-    const parameter =
-      (key: IRequestQueryValidator<any>["type"]) =>
-      (
-        programmer: (next: {
-          context: ITypiaContext;
-          modulo: ts.LeftHandSideExpression;
-          type: ts.Type;
-          name: string | undefined;
-        }) => 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,
-            }),
-          ),
-        ]);
-
-    // 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 TypedQueryBodyProgrammer {
+  export const generate = (props: {
+    context: INestiaTransformContext;
+    modulo: ts.LeftHandSideExpression;
+    type: ts.Type;
+  }): ts.ObjectLiteralExpression => {
+    // 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 VALIDATION PLAN
+    const parameter =
+      (key: IRequestQueryValidator<any>["type"]) =>
+      (
+        programmer: (next: {
+          context: ITypiaContext;
+          modulo: ts.LeftHandSideExpression;
+          type: ts.Type;
+          name: string | undefined;
+        }) => 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,
+            }),
+          ),
+        ]);
+
+    // 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/TypedQueryProgrammer.ts

@@ -1,114 +1,114 @@
-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);
-  };
-}
+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);
+  };
+}