@nestia/core 11.0.0-dev.20260313-4 → 11.0.0-dev.20260316

package/src/options/IRequestHeadersValidator.ts

@@ -1,22 +1,22 @@
-import { IValidation } from "typia";
-
-export type IRequestHeadersValidator<T> =
-  | IRequestHeadersValidator.IAssert<T>
-  | IRequestHeadersValidator.IIs<T>
-  | IRequestHeadersValidator.IValidate<T>;
-export namespace IRequestHeadersValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: Record<string, string | string[] | undefined>) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: Record<string, string | string[] | undefined>) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (
-      input: Record<string, string | string[] | undefined>,
-    ) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestHeadersValidator<T> =
+  | IRequestHeadersValidator.IAssert<T>
+  | IRequestHeadersValidator.IIs<T>
+  | IRequestHeadersValidator.IValidate<T>;
+export namespace IRequestHeadersValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: Record<string, string | string[] | undefined>) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: Record<string, string | string[] | undefined>) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (
+      input: Record<string, string | string[] | undefined>,
+    ) => IValidation<T>;
+  }
+}

package/src/options/IRequestQueryValidator.ts

@@ -1,20 +1,20 @@
-import { IValidation } from "typia";
-
-export type IRequestQueryValidator<T> =
-  | IRequestQueryValidator.IAssert<T>
-  | IRequestQueryValidator.IIs<T>
-  | IRequestQueryValidator.IValidate<T>;
-export namespace IRequestQueryValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: URLSearchParams) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: URLSearchParams) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: URLSearchParams) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestQueryValidator<T> =
+  | IRequestQueryValidator.IAssert<T>
+  | IRequestQueryValidator.IIs<T>
+  | IRequestQueryValidator.IValidate<T>;
+export namespace IRequestQueryValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: URLSearchParams) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: URLSearchParams) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: URLSearchParams) => IValidation<T>;
+  }
+}

package/src/options/IResponseBodyQuerifier.ts

@@ -1,25 +1,25 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyQuerifier<T> =
-  | IResponseBodyquerifier.IStringify<T>
-  | IResponseBodyquerifier.IIs<T>
-  | IResponseBodyquerifier.IAssert<T>
-  | IResponseBodyquerifier.IValidate<T>;
-export namespace IResponseBodyquerifier {
-  export interface IStringify<T> {
-    type: "stringify";
-    stringify: (input: T) => URLSearchParams;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => URLSearchParams | null;
-  }
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => URLSearchParams;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<URLSearchParams>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyQuerifier<T> =
+  | IResponseBodyquerifier.IStringify<T>
+  | IResponseBodyquerifier.IIs<T>
+  | IResponseBodyquerifier.IAssert<T>
+  | IResponseBodyquerifier.IValidate<T>;
+export namespace IResponseBodyquerifier {
+  export interface IStringify<T> {
+    type: "stringify";
+    stringify: (input: T) => URLSearchParams;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => URLSearchParams | null;
+  }
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => URLSearchParams;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<URLSearchParams>;
+  }
+}

package/src/options/IResponseBodyStringifier.ts

@@ -1,30 +1,30 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyStringifier<T> =
-  | IResponseBodyStringifier.IStringify<T>
-  | IResponseBodyStringifier.IIs<T>
-  | IResponseBodyStringifier.IAssert<T>
-  | IResponseBodyStringifier.IValidate<T>
-  | IResponseBodyStringifier.IValidateLog<T>;
-export namespace IResponseBodyStringifier {
-  export interface IStringify<T> {
-    type: "stringify";
-    stringify: (input: T) => string;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => string | null;
-  }
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => string;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<string>;
-  }
-  export interface IValidateLog<T> {
-    type: "validate.log";
-    validate: (input: T) => IValidation<string>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyStringifier<T> =
+  | IResponseBodyStringifier.IStringify<T>
+  | IResponseBodyStringifier.IIs<T>
+  | IResponseBodyStringifier.IAssert<T>
+  | IResponseBodyStringifier.IValidate<T>
+  | IResponseBodyStringifier.IValidateLog<T>;
+export namespace IResponseBodyStringifier {
+  export interface IStringify<T> {
+    type: "stringify";
+    stringify: (input: T) => string;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => string | null;
+  }
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => string;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<string>;
+  }
+  export interface IValidateLog<T> {
+    type: "validate.log";
+    validate: (input: T) => IValidation<string>;
+  }
+}

package/src/programmers/PlainBodyProgrammer.ts

@@ -22,7 +22,7 @@ export namespace PlainBodyProgrammer {
         escape: false,
         constant: true,
         absorb: true,
-        validate,
+        validate: ({ metadata }) => validate(metadata),
       },
       components: new MetadataCollection(),
       type: props.type,

package/src/programmers/TypedBodyProgrammer.ts

@@ -28,12 +28,16 @@ export namespace TypedBodyProgrammer {
       transformer: props.context.transformer,
       type: props.type,
       validate: props.context.options.llm
-        ? (metadata) =>
+        ? (next) =>
             LlmSchemaProgrammer.validate({
               config: {
-                strict: props.context.options.llm?.strict ?? false,
+                strict:
+                  typeof props.context.options.llm === "boolean"
+                    ? false
+                    : (props.context.options.llm?.strict ?? false),
               },
-              metadata,
+              metadata: next.metadata,
+              explore: next.explore,
             })
         : undefined,
     });

package/src/programmers/TypedQueryBodyProgrammer.ts

@@ -25,7 +25,8 @@ export namespace TypedQueryBodyProgrammer {
   }): ts.ObjectLiteralExpression => {
     // VALIDATE TYPE
     if (props.context.options.llm) {
-      const llm: INestiaTransformOptions.ILlm = props.context.options.llm;
+      const llm: INestiaTransformOptions.ILlm | true =
+        props.context.options.llm;
       const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
         MetadataFactory.analyze({
           checker: props.context.checker,
@@ -34,18 +35,19 @@ export namespace TypedQueryBodyProgrammer {
             escape: false,
             constant: true,
             absorb: true,
-            validate: (meta, explore) => {
-              const errors: string[] = HttpQueryProgrammer.validate(
-                meta,
-                explore,
-                true,
-              );
+            validate: (next) => {
+              const errors: string[] = HttpQueryProgrammer.validate({
+                metadata: next.metadata,
+                explore: next.explore,
+                allowOptional: true,
+              });
               errors.push(
                 ...LlmSchemaProgrammer.validate({
                   config: {
-                    strict: llm.strict ?? false,
+                    strict: llm === true ? false : (llm.strict ?? false),
                   },
-                  metadata: meta,
+                  metadata: next.metadata,
+                  explore: next.explore,
                 }),
               );
               return errors;

package/src/programmers/TypedQueryProgrammer.ts

@@ -25,7 +25,8 @@ export namespace TypedQueryProgrammer {
   }): ts.Expression => {
     // VALIDATE TYPE
     if (props.context.options.llm) {
-      const llm: INestiaTransformOptions.ILlm = props.context.options.llm;
+      const llm: INestiaTransformOptions.ILlm | true =
+        props.context.options.llm;
       const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
         MetadataFactory.analyze({
           checker: props.context.checker,
@@ -34,18 +35,19 @@ export namespace TypedQueryProgrammer {
             escape: false,
             constant: true,
             absorb: true,
-            validate: (meta, explore) => {
-              const errors: string[] = HttpQueryProgrammer.validate(
-                meta,
-                explore,
-                true,
-              );
+            validate: (next) => {
+              const errors: string[] = HttpQueryProgrammer.validate({
+                metadata: next.metadata,
+                explore: next.explore,
+                allowOptional: true,
+              });
               errors.push(
                 ...LlmSchemaProgrammer.validate({
                   config: {
-                    strict: llm.strict ?? false,
+                    strict: llm === true ? false : (llm.strict ?? false),
                   },
-                  metadata: meta,
+                  metadata: next.metadata,
+                  explore: next.explore,
                 }),
               );
               return errors;

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -1,7 +1,7 @@
 import {
   HttpQueryProgrammer,
   ITypiaContext,
-  LlmSchemaProgrammer,
+  LlmParametersProgrammer,
   MetadataCollection,
   MetadataFactory,
   MetadataSchema,
@@ -25,7 +25,8 @@ export namespace TypedQueryRouteProgrammer {
   }): ts.Expression => {
     // VALIDATE TYPE
     if (props.context.options.llm) {
-      const llm: INestiaTransformOptions.ILlm = props.context.options.llm;
+      const llm: INestiaTransformOptions.ILlm | true =
+        props.context.options.llm;
       const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
         MetadataFactory.analyze({
           checker: props.context.checker,
@@ -34,20 +35,22 @@ export namespace TypedQueryRouteProgrammer {
             escape: false,
             constant: true,
             absorb: true,
-            validate: (meta, explore) => {
-              const errors: string[] = HttpQueryProgrammer.validate(
-                meta,
-                explore,
-                true,
-              );
-              errors.push(
-                ...LlmSchemaProgrammer.validate({
-                  config: {
-                    strict: llm.strict ?? false,
-                  },
-                  metadata: meta,
-                }),
-              );
+            validate: (next) => {
+              const errors: string[] = HttpQueryProgrammer.validate({
+                metadata: next.metadata,
+                explore: next.explore,
+                allowOptional: true,
+              });
+              if (next.metadata.size() !== 0)
+                errors.push(
+                  ...LlmParametersProgrammer.validate({
+                    config: {
+                      strict: llm === true ? false : (llm.strict ?? false),
+                    },
+                    metadata: next.metadata,
+                    explore: next.explore,
+                  }),
+                );
               return errors;
             },
           },

package/src/programmers/TypedRouteProgrammer.ts

@@ -5,10 +5,11 @@ import {
   JsonMetadataFactory,
   JsonStringifyProgrammer,
   JsonValidateStringifyProgrammer,
-  LlmSchemaProgrammer,
+  LlmParametersProgrammer,
 } from "@typia/core";
 import ts from "typescript";
 
+import { INestiaTransformOptions } from "../options/INestiaTransformOptions";
 import { INestiaTransformContext } from "../options/INestiaTransformProject";
 
 export namespace TypedRouteProgrammer {
@@ -18,20 +19,26 @@ export namespace TypedRouteProgrammer {
     type: ts.Type;
   }): ts.Expression => {
     // VALIDATE TYPE
-    if (props.context.options.llm)
+    if (props.context.options.llm) {
+      const llm: INestiaTransformOptions.ILlm | true =
+        props.context.options.llm;
       JsonMetadataFactory.analyze({
         method: "@nestia.core.TypedRoute",
         checker: props.context.checker,
         transformer: props.context.transformer,
         type: props.type,
-        validate: (metadata) =>
-          LlmSchemaProgrammer.validate({
+        validate: (next) => {
+          if (next.metadata.size() === 0) return [];
+          return LlmParametersProgrammer.validate({
             config: {
-              strict: props.context.options.llm?.strict ?? false,
+              strict: llm === true ? false : (llm.strict ?? false),
             },
-            metadata,
-          }),
+            metadata: next.metadata,
+            explore: next.explore,
+          });
+        },
       });
+    }
 
     // GENERATE STRINGIFY PLAN
     const parameter = (next: {

package/src/transformers/NodeTransformer.ts

@@ -1,23 +1,23 @@
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { MethodTransformer } from "./MethodTransformer";
-import { ParameterTransformer } from "./ParameterTransformer";
-
-export namespace NodeTransformer {
-  export const transform = (props: {
-    context: INestiaTransformContext;
-    node: ts.Node;
-  }): ts.Node =>
-    ts.isMethodDeclaration(props.node)
-      ? MethodTransformer.transform({
-          context: props.context,
-          method: props.node,
-        })
-      : ts.isParameter(props.node)
-        ? ParameterTransformer.transform({
-            context: props.context,
-            param: props.node,
-          })
-        : props.node;
-}
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { MethodTransformer } from "./MethodTransformer";
+import { ParameterTransformer } from "./ParameterTransformer";
+
+export namespace NodeTransformer {
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.isMethodDeclaration(props.node)
+      ? MethodTransformer.transform({
+          context: props.context,
+          method: props.node,
+        })
+      : ts.isParameter(props.node)
+        ? ParameterTransformer.transform({
+            context: props.context,
+            param: props.node,
+          })
+        : props.node;
+}

package/src/transformers/ParameterTransformer.ts

@@ -1,57 +1,57 @@
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { ParameterDecoratorTransformer } from "./ParameterDecoratorTransformer";
-
-export namespace ParameterTransformer {
-  export const transform = (props: {
-    context: INestiaTransformContext;
-    param: ts.ParameterDeclaration;
-  }): ts.ParameterDeclaration => {
-    // CHECK DECORATOR
-    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-      ? ts.getDecorators(props.param)
-      : (props.param as any).decorators;
-    if (!decorators?.length) return props.param;
-
-    // GET TYPE INFO
-    const type: ts.Type = props.context.checker.getTypeAtLocation(props.param);
-
-    // WHEN LATEST TS VERSION
-    if (ts.getDecorators !== undefined)
-      return ts.factory.updateParameterDeclaration(
-        props.param,
-        (props.param.modifiers || []).map((mod) =>
-          ts.isDecorator(mod)
-            ? ParameterDecoratorTransformer.transform({
-                context: props.context,
-                decorator: mod,
-                type,
-              })
-            : mod,
-        ),
-        props.param.dotDotDotToken,
-        props.param.name,
-        props.param.questionToken,
-        props.param.type,
-        props.param.initializer,
-      );
-    // eslint-disable-next-line
-    return (ts.factory.updateParameterDeclaration as any)(
-      props.param,
-      decorators.map((deco) =>
-        ParameterDecoratorTransformer.transform({
-          context: props.context,
-          decorator: deco,
-          type,
-        }),
-      ),
-      (props.param as any).modifiers,
-      props.param.dotDotDotToken,
-      props.param.name,
-      props.param.questionToken,
-      props.param.type,
-      props.param.initializer,
-    );
-  };
-}
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { ParameterDecoratorTransformer } from "./ParameterDecoratorTransformer";
+
+export namespace ParameterTransformer {
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    param: ts.ParameterDeclaration;
+  }): ts.ParameterDeclaration => {
+    // CHECK DECORATOR
+    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+      ? ts.getDecorators(props.param)
+      : (props.param as any).decorators;
+    if (!decorators?.length) return props.param;
+
+    // GET TYPE INFO
+    const type: ts.Type = props.context.checker.getTypeAtLocation(props.param);
+
+    // WHEN LATEST TS VERSION
+    if (ts.getDecorators !== undefined)
+      return ts.factory.updateParameterDeclaration(
+        props.param,
+        (props.param.modifiers || []).map((mod) =>
+          ts.isDecorator(mod)
+            ? ParameterDecoratorTransformer.transform({
+                context: props.context,
+                decorator: mod,
+                type,
+              })
+            : mod,
+        ),
+        props.param.dotDotDotToken,
+        props.param.name,
+        props.param.questionToken,
+        props.param.type,
+        props.param.initializer,
+      );
+    // eslint-disable-next-line
+    return (ts.factory.updateParameterDeclaration as any)(
+      props.param,
+      decorators.map((deco) =>
+        ParameterDecoratorTransformer.transform({
+          context: props.context,
+          decorator: deco,
+          type,
+        }),
+      ),
+      (props.param as any).modifiers,
+      props.param.dotDotDotToken,
+      props.param.name,
+      props.param.questionToken,
+      props.param.type,
+      props.param.initializer,
+    );
+  };
+}

package/src/typings/Creator.ts

@@ -1,3 +1,3 @@
-export type Creator<T extends object> = {
-  new (...args: any[]): T;
-};
+export type Creator<T extends object> = {
+  new (...args: any[]): T;
+};

package/src/typings/get-function-location.d.ts

@@ -1,7 +1,7 @@
-declare module "get-function-location" {
-  export default function (func: any): Promise<{
-    source: string;
-    line: number;
-    column: number;
-  }>;
-}
+declare module "get-function-location" {
+  export default function (func: any): Promise<{
+    source: string;
+    line: number;
+    column: number;
+  }>;
+}

package/src/utils/ArrayUtil.ts

@@ -1,7 +1,7 @@
-export namespace ArrayUtil {
-  export function has<T>(array: T[], ...items: T[]): boolean {
-    return items.every(
-      (elem) => array.find((org) => org === elem) !== undefined,
-    );
-  }
-}
+export namespace ArrayUtil {
+  export function has<T>(array: T[], ...items: T[]): boolean {
+    return items.every(
+      (elem) => array.find((org) => org === elem) !== undefined,
+    );
+  }
+}