@nestia/core 2.4.2 → 2.4.3-dev.20231207

package/src/decorators/internal/validate_request_headers.ts

@@ -1,73 +1,68 @@
-import { BadRequestException } from "@nestjs/common";
-
-import typia, { IValidation, TypeGuardError } from "typia";
-
-import { IRequestHeadersValidator } from "../../options/IRequestHeadersValidator";
-import { NoTransformConfigureError } from "./NoTransformConfigureError";
-
-export const validate_request_headers = <T>(
-    validator?: IRequestHeadersValidator<T>,
-) => {
-    if (!validator) return () => NoTransformConfigureError("TypedHeaders");
-    else if (validator.type === "assert") return assert(validator.assert);
-    else if (validator.type === "is") return is(validator.is);
-    else if (validator.type === "validate") return validate(validator.validate);
-    return () =>
-        new Error(
-            `Error on nestia.core.TypedHeaders(): invalid typed validator.`,
-        );
-};
-
-const assert =
-    <T>(closure: (input: Record<string, string | string[] | undefined>) => T) =>
-    (
-        input: Record<string, string | string[] | undefined>,
-    ): T | BadRequestException => {
-        try {
-            return closure(input);
-        } catch (exp) {
-            if (typia.is<TypeGuardError>(exp)) {
-                return new BadRequestException({
-                    path: exp.path,
-                    reason: exp.message,
-                    expected: exp.expected,
-                    value: exp.value,
-                    message: MESSAGE,
-                });
-            }
-            throw exp;
-        }
-    };
-
-const is =
-    <T>(
-        closure: (
-            input: Record<string, string | string[] | undefined>,
-        ) => T | null,
-    ) =>
-    (
-        input: Record<string, string | string[] | undefined>,
-    ): T | BadRequestException => {
-        const result: T | null = closure(input);
-        return result !== null ? result : new BadRequestException(MESSAGE);
-    };
-
-const validate =
-    <T>(
-        closure: (
-            input: Record<string, string | string[] | undefined>,
-        ) => IValidation<T>,
-    ) =>
-    (
-        input: Record<string, string | string[] | undefined>,
-    ): T | BadRequestException => {
-        const result: IValidation<T> = closure(input);
-        return result.success
-            ? result.data
-            : new BadRequestException({
-                  errors: result.errors,
-                  message: MESSAGE,
-              });
-    };
-
-const MESSAGE = "Request headers data is not following the promised type.";
+import { BadRequestException } from "@nestjs/common";
+import typia, { IValidation, TypeGuardError } from "typia";
+
+import { IRequestHeadersValidator } from "../../options/IRequestHeadersValidator";
+import { NoTransformConfigureError } from "./NoTransformConfigureError";
+
+export const validate_request_headers = <T>(
+  validator?: IRequestHeadersValidator<T>,
+) => {
+  if (!validator) return () => NoTransformConfigureError("TypedHeaders");
+  else if (validator.type === "assert") return assert(validator.assert);
+  else if (validator.type === "is") return is(validator.is);
+  else if (validator.type === "validate") return validate(validator.validate);
+  return () =>
+    new Error(`Error on nestia.core.TypedHeaders(): invalid typed validator.`);
+};
+
+const assert =
+  <T>(closure: (input: Record<string, string | string[] | undefined>) => T) =>
+  (
+    input: Record<string, string | string[] | undefined>,
+  ): T | BadRequestException => {
+    try {
+      return closure(input);
+    } catch (exp) {
+      if (typia.is<TypeGuardError>(exp)) {
+        return new BadRequestException({
+          path: exp.path,
+          reason: exp.message,
+          expected: exp.expected,
+          value: exp.value,
+          message: MESSAGE,
+        });
+      }
+      throw exp;
+    }
+  };
+
+const is =
+  <T>(
+    closure: (input: Record<string, string | string[] | undefined>) => T | null,
+  ) =>
+  (
+    input: Record<string, string | string[] | undefined>,
+  ): T | BadRequestException => {
+    const result: T | null = closure(input);
+    return result !== null ? result : new BadRequestException(MESSAGE);
+  };
+
+const validate =
+  <T>(
+    closure: (
+      input: Record<string, string | string[] | undefined>,
+    ) => IValidation<T>,
+  ) =>
+  (
+    input: Record<string, string | string[] | undefined>,
+  ): T | BadRequestException => {
+    const result: IValidation<T> = closure(input);
+    return result.success
+      ? result.data
+      : new BadRequestException({
+          errors: result.errors,
+          message: MESSAGE,
+        });
+  };
+
+const MESSAGE = "Request headers data is not following the promised type.";

package/src/decorators/internal/validate_request_query.ts

@@ -1,59 +1,56 @@
-import { BadRequestException } from "@nestjs/common";
-
-import typia, { IValidation, TypeGuardError } from "typia";
-
-import { IRequestQueryValidator } from "../../options/IRequestQueryValidator";
-import { NoTransformConfigureError } from "./NoTransformConfigureError";
-
-export const validate_request_query = <T>(
-    validator?: IRequestQueryValidator<T>,
-) => {
-    if (!validator) return () => NoTransformConfigureError("TypedQuery");
-    else if (validator.type === "assert") return assert(validator.assert);
-    else if (validator.type === "is") return is(validator.is);
-    else if (validator.type === "validate") return validate(validator.validate);
-    return () =>
-        new Error(
-            `Error on nestia.core.TypedQuery(): invalid typed validator.`,
-        );
-};
-
-const assert =
-    <T>(closure: (input: URLSearchParams) => T) =>
-    (input: URLSearchParams): T | BadRequestException => {
-        try {
-            return closure(input);
-        } catch (exp) {
-            if (typia.is<TypeGuardError>(exp)) {
-                return new BadRequestException({
-                    path: exp.path,
-                    reason: exp.message,
-                    expected: exp.expected,
-                    value: exp.value,
-                    message: MESSAGE,
-                });
-            }
-            throw exp;
-        }
-    };
-
-const is =
-    <T>(closure: (input: URLSearchParams) => T | null) =>
-    (input: URLSearchParams): T | BadRequestException => {
-        const result: T | null = closure(input);
-        return result !== null ? result : new BadRequestException(MESSAGE);
-    };
-
-const validate =
-    <T>(closure: (input: URLSearchParams) => IValidation<T>) =>
-    (input: URLSearchParams): T | BadRequestException => {
-        const result: IValidation<T> = closure(input);
-        return result.success
-            ? result.data
-            : new BadRequestException({
-                  errors: result.errors,
-                  message: MESSAGE,
-              });
-    };
-
-const MESSAGE = "Request query data is not following the promised type.";
+import { BadRequestException } from "@nestjs/common";
+import typia, { IValidation, TypeGuardError } from "typia";
+
+import { IRequestQueryValidator } from "../../options/IRequestQueryValidator";
+import { NoTransformConfigureError } from "./NoTransformConfigureError";
+
+export const validate_request_query = <T>(
+  validator?: IRequestQueryValidator<T>,
+) => {
+  if (!validator) return () => NoTransformConfigureError("TypedQuery");
+  else if (validator.type === "assert") return assert(validator.assert);
+  else if (validator.type === "is") return is(validator.is);
+  else if (validator.type === "validate") return validate(validator.validate);
+  return () =>
+    new Error(`Error on nestia.core.TypedQuery(): invalid typed validator.`);
+};
+
+const assert =
+  <T>(closure: (input: URLSearchParams) => T) =>
+  (input: URLSearchParams): T | BadRequestException => {
+    try {
+      return closure(input);
+    } catch (exp) {
+      if (typia.is<TypeGuardError>(exp)) {
+        return new BadRequestException({
+          path: exp.path,
+          reason: exp.message,
+          expected: exp.expected,
+          value: exp.value,
+          message: MESSAGE,
+        });
+      }
+      throw exp;
+    }
+  };
+
+const is =
+  <T>(closure: (input: URLSearchParams) => T | null) =>
+  (input: URLSearchParams): T | BadRequestException => {
+    const result: T | null = closure(input);
+    return result !== null ? result : new BadRequestException(MESSAGE);
+  };
+
+const validate =
+  <T>(closure: (input: URLSearchParams) => IValidation<T>) =>
+  (input: URLSearchParams): T | BadRequestException => {
+    const result: IValidation<T> = closure(input);
+    return result.success
+      ? result.data
+      : new BadRequestException({
+          errors: result.errors,
+          message: MESSAGE,
+        });
+  };
+
+const MESSAGE = "Request query data is not following the promised type.";

package/src/index.ts

@@ -1,5 +1,5 @@
-import * as core from "./module";
-
-export * from "./module";
-
-export default core;
+import * as core from "./module";
+
+export * from "./module";
+
+export default core;

package/src/module.ts

@@ -1,14 +1,14 @@
-export * from "./decorators/DynamicModule";
-export * from "./decorators/EncryptedBody";
-export * from "./decorators/EncryptedController";
-export * from "./decorators/EncryptedModule";
-export * from "./decorators/EncryptedRoute";
-export * from "./utils/ExceptionManager";
-export * from "./decorators/PlainBody";
-export * from "./decorators/TypedBody";
-export * from "./decorators/TypedException";
-export * from "./decorators/TypedHeaders";
-export * from "./decorators/TypedParam";
-export * from "./decorators/TypedRoute";
-export * from "./decorators/TypedQuery";
-export * from "./options/INestiaTransformOptions";
+export * from "./decorators/DynamicModule";
+export * from "./decorators/EncryptedBody";
+export * from "./decorators/EncryptedController";
+export * from "./decorators/EncryptedModule";
+export * from "./decorators/EncryptedRoute";
+export * from "./utils/ExceptionManager";
+export * from "./decorators/PlainBody";
+export * from "./decorators/TypedBody";
+export * from "./decorators/TypedException";
+export * from "./decorators/TypedHeaders";
+export * from "./decorators/TypedParam";
+export * from "./decorators/TypedRoute";
+export * from "./decorators/TypedQuery";
+export * from "./options/INestiaTransformOptions";

package/src/options/INestiaTransformOptions.ts

@@ -1,17 +1,17 @@
-export interface INestiaTransformOptions {
-    validate?: // NORMAL
-    | "assert"
-        | "is"
-        | "validate"
-        // STRICT
-        | "assertEquals"
-        | "equals"
-        | "validateEquals"
-        // CLONE
-        | "assertClone"
-        | "validateClone"
-        // PRUNE
-        | "assertPrune"
-        | "validatePrune";
-    stringify?: "stringify" | "assert" | "is" | "validate" | null;
-}
+export interface INestiaTransformOptions {
+  validate?: // NORMAL
+  | "assert"
+    | "is"
+    | "validate"
+    // STRICT
+    | "assertEquals"
+    | "equals"
+    | "validateEquals"
+    // CLONE
+    | "assertClone"
+    | "validateClone"
+    // PRUNE
+    | "assertPrune"
+    | "validatePrune";
+  stringify?: "stringify" | "assert" | "is" | "validate" | null;
+}

package/src/options/INestiaTransformProject.ts

@@ -1,7 +1,7 @@
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformOptions } from "./INestiaTransformOptions";
-
-export interface INestiaTransformProject extends Omit<IProject, "options"> {
-    options: INestiaTransformOptions;
-}
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformOptions } from "./INestiaTransformOptions";
+
+export interface INestiaTransformProject extends Omit<IProject, "options"> {
+  options: INestiaTransformOptions;
+}

package/src/options/IRequestBodyValidator.ts

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

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,25 +1,25 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyStringifier<T> =
-    | IResponseBodyStringifier.IStringify<T>
-    | IResponseBodyStringifier.IIs<T>
-    | IResponseBodyStringifier.IAssert<T>
-    | IResponseBodyStringifier.IValidate<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>;
-    }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyStringifier<T> =
+  | IResponseBodyStringifier.IStringify<T>
+  | IResponseBodyStringifier.IIs<T>
+  | IResponseBodyStringifier.IAssert<T>
+  | IResponseBodyStringifier.IValidate<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>;
+  }
+}