@nestia/core 2.0.0-dev.20230831-5 → 2.0.0-dev.20230991

package/src/decorators/EncryptedRoute.ts

@@ -16,17 +16,12 @@ import { HttpArgumentsHost } from "@nestjs/common/interfaces";
 import express from "express";
 import { catchError, map } from "rxjs/operators";
 
-import {
-    assertStringify,
-    isStringify,
-    stringify,
-    validateStringify,
-} from "typia";
+import typia from "typia";
 
 import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
 import { Singleton } from "../utils/Singleton";
 import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-import { TransformError } from "./internal/TransformError";
+import { NoTransformConfigureError } from "./internal/NoTransformConfigureError";
 import { get_path_and_stringify } from "./internal/get_path_and_stringify";
 import { headers_to_object } from "./internal/headers_to_object";
 import { route_error } from "./internal/route_error";
@@ -118,10 +113,10 @@ export namespace EncryptedRoute {
 }
 
 for (const method of [
-    isStringify,
-    assertStringify,
-    validateStringify,
-    stringify,
+    typia.json.isStringify,
+    typia.json.assertStringify,
+    typia.json.validateStringify,
+    typia.json.stringify,
 ])
     for (const [key, value] of Object.entries(method))
         for (const deco of [
@@ -154,7 +149,9 @@ class EncryptedRouteInterceptor implements NestInterceptor {
                     context.getClass(),
                 );
                 if (!param)
-                    throw TransformError(`EncryptedRoute.${this.method}`);
+                    throw NoTransformConfigureError(
+                        `EncryptedRoute.${this.method}`,
+                    );
 
                 const headers: Singleton<Record<string, string>> =
                     new Singleton(() => {

package/src/decorators/TypedHeaders.ts

@@ -8,7 +8,7 @@ import type { FastifyRequest } from "fastify";
 
 import typia, { TypeGuardError, assert } from "typia";
 
-import { TransformError } from "./internal/TransformError";
+import { NoTransformConfigureError } from "./internal/NoTransformConfigureError";
 
 /**
  * Type safe HTTP headers decorator.
@@ -54,7 +54,7 @@ import { TransformError } from "./internal/TransformError";
 export function TypedHeaders<T extends object>(
     decoder?: (headers: Record<string, string | string[] | undefined>) => T,
 ): ParameterDecorator {
-    if (decoder === undefined) throw TransformError("TypedHeaders");
+    if (decoder === undefined) throw NoTransformConfigureError("TypedHeaders");
 
     return createParamDecorator(function TypedHeaders(
         _unknown: any,

package/src/decorators/TypedParam.ts

@@ -6,81 +6,60 @@ import {
 import type express from "express";
 import type { FastifyRequest } from "fastify";
 
+import { NoTransformConfigureError } from "./internal/NoTransformConfigureError";
+
 /**
  * Type safe URL parameter decorator.
  *
  * `TypedParam` is a decorator function getting specific typed parameter from the
  * HTTP request URL. It's almost same with the {@link nest.Param}, but `TypedParam`
- * automatically casts parameter value to be following its type. Beside, the
- * {@link nest.Param} always parses all of the parameters as `string` type.
- *
- * Note that, if you just omit the `type` and `nullable` parameters, then
- * `TypedParam` automatically determines the `type` and `nullable` values
- * just by analyzing the parameter type. Only when you need to specify them
- * are, you want to use the `uuid` type.
+ * automatically casts parameter value to be following its type, and validates it.
  *
  * ```typescript
+ * import { tags } from "typia";
+ *
  * \@TypedRoute.Get("shopping/sales/:id/:no/:paused")
  * public async pause
  *     (
- *         \@TypedParam("id", "uuid"), id: string, // uuid specification
- *         \@TypedParam("no") id: number, // auto casting
- *         \@TypedParam("paused") paused: boolean | null // auto casting
+ *         \@TypedParam("id", "uuid"), id: string & tags.Format<"uuid">,
+ *         \@TypedParam("no") id: number & tags.Type<"uint32">
+ *         \@TypedParam("paused") paused: boolean | null
  *     ): Promise<void>;
  * ```
  *
  * @param name URL Parameter name
- * @param type If omit, automatically determined by the parameter type.
- * @param nullable If omit, automatically determined by the parameter type.
  * @returns Parameter decorator
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
 export function TypedParam(
     name: string,
-    type?: "boolean" | "number" | "string" | "uuid" | "date",
-    nullable?: false | true,
+    props?: TypedParam.IProps<any>,
 ): ParameterDecorator {
-    function TypedParam({}: any, context: ExecutionContext) {
+    if (props === undefined) throw NoTransformConfigureError("TypedParam");
+
+    return createParamDecorator(function TypedParam(
+        {}: any,
+        context: ExecutionContext,
+    ) {
         const request: express.Request | FastifyRequest = context
             .switchToHttp()
             .getRequest();
         const str: string = (request.params as any)[name];
-
-        if (nullable === true && str === "null") return null;
-        else if (type === "boolean") {
-            if (str === "true" || str === "1") return true;
-            else if (str === "false" || str === "0") return false;
-            else
-                throw new BadRequestException(
-                    `Value of the URL parameter '${name}' is not a boolean.`,
-                );
-        } else if (type === "number") {
-            const value: number = Number(str);
-            if (isNaN(value))
-                throw new BadRequestException(
-                    `Value of the URL parameter "${name}" is not a number.`,
-                );
-            return value;
-        } else if (type === "uuid") {
-            if (UUID_PATTERN.test(str) === false)
-                throw new BadRequestException(
-                    `Value of the URL parameter "${name}" is not a valid UUID.`,
-                );
-            return str;
-        } else if (type === "date") {
-            if (DATE_PATTERN.test(str) === false)
-                throw new BadRequestException(
-                    `Value of the URL parameter "${name}" is not a valid date.`,
-                );
-            return str;
-        } else return str;
+        const value: any = props!.cast(str);
+        if (props!.is(value) === false)
+            throw new BadRequestException(
+                `Value of the URL parameter "${name}" is not ${
+                    props!.type
+                } type.`,
+            );
+        return value;
+    })(name);
+}
+export namespace TypedParam {
+    export interface IProps<T> {
+        type: string;
+        cast: (value: string) => T;
+        is: (value: T) => boolean;
     }
-    (TypedParam as any).nullable = !!nullable;
-    (TypedParam as any).type = type;
-    return createParamDecorator(TypedParam)(name);
 }
-
-const UUID_PATTERN =
-    /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
-const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;

package/src/decorators/TypedQuery.ts

@@ -8,7 +8,7 @@ import type { FastifyRequest } from "fastify";
 
 import typia, { TypeGuardError, assert } from "typia";
 
-import { TransformError } from "./internal/TransformError";
+import { NoTransformConfigureError } from "./internal/NoTransformConfigureError";
 
 /**
  * Type safe URL query decorator.
@@ -23,9 +23,8 @@ import { TransformError } from "./internal/TransformError";
  *
  * 1. Type `T` must be an object type
  * 2. Do not allow dynamic property
- * 3. Prpoerty value cannot be `undefined`, but `null` is possible
- * 4. Only `boolean`, `bigint`, `number`, `string` or their array types are allowed
- * 5. By the way, union type never be not allowed
+ * 3. Only `boolean`, `bigint`, `number`, `string` or their array types are allowed
+ * 4. By the way, union type never be not allowed
  *
  * @returns Parameter decorator
  * @author Jeongho Nam - https://github.com/samchon
@@ -33,7 +32,7 @@ import { TransformError } from "./internal/TransformError";
 export function TypedQuery<T extends object>(
     decoder?: (params: URLSearchParams) => T,
 ): ParameterDecorator {
-    if (decoder === undefined) throw TransformError("TypedQuery");
+    if (decoder === undefined) throw NoTransformConfigureError("TypedQuery");
 
     return createParamDecorator(function TypedQuery(
         _unknown: any,

package/src/decorators/TypedRoute.ts

@@ -14,12 +14,7 @@ import { HttpArgumentsHost } from "@nestjs/common/interfaces";
 import express from "express";
 import { catchError, map } from "rxjs/operators";
 
-import {
-    assertStringify,
-    isStringify,
-    stringify,
-    validateStringify,
-} from "typia";
+import typia from "typia";
 
 import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
 import { get_path_and_stringify } from "./internal/get_path_and_stringify";
@@ -107,10 +102,10 @@ export namespace TypedRoute {
     }
 }
 for (const method of [
-    stringify,
-    isStringify,
-    assertStringify,
-    validateStringify,
+    typia.json.stringify,
+    typia.json.isStringify,
+    typia.json.assertStringify,
+    typia.json.validateStringify,
 ])
     for (const [key, value] of Object.entries(method))
         for (const deco of [

package/src/decorators/internal/{TransformError.ts → NoTransformConfigureError.ts}

@@ -1,7 +1,7 @@
 /**
  * @internal
  */
-export function TransformError(method: string): Error {
+export function NoTransformConfigureError(method: string): Error {
     return new Error(
         `Error on nestia.core.${method}(): no transform has been configured. Run "npx typia setup" command, or check if you're using non-standard TypeScript compiler like Babel or SWC.`,
     );

package/src/decorators/internal/get_path_and_stringify.ts

@@ -3,7 +3,7 @@ import { InternalServerErrorException } from "@nestjs/common";
 import typia, { IValidation, TypeGuardError } from "typia";
 
 import { IResponseBodyStringifier } from "../../options/IResponseBodyStringifier";
-import { TransformError } from "./TransformError";
+import { NoTransformConfigureError } from "./NoTransformConfigureError";
 
 export const get_path_and_stringify =
     (method: string) =>
@@ -24,7 +24,7 @@ export const get_path_and_stringify =
 const take =
     (method: string) =>
     <T>(functor?: IResponseBodyStringifier<T> | null) => {
-        if (functor === undefined) throw TransformError(method);
+        if (functor === undefined) throw NoTransformConfigureError(method);
         else if (functor === null) return JSON.stringify;
         else if (functor.type === "stringify") return functor.stringify;
         else if (functor.type === "assert") return assert(functor.assert);

package/src/decorators/internal/validate_request_body.ts

@@ -3,12 +3,12 @@ import { BadRequestException } from "@nestjs/common";
 import typia, { IValidation, TypeGuardError } from "typia";
 
 import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
-import { TransformError } from "./TransformError";
+import { NoTransformConfigureError } from "./NoTransformConfigureError";
 
 export const validate_request_body =
     (method: string) =>
     <T>(validator?: IRequestBodyValidator<T>) => {
-        if (!validator) return () => TransformError(method);
+        if (!validator) return () => NoTransformConfigureError(method);
         else if (validator.type === "assert") return assert(validator.assert);
         else if (validator.type === "is") return is(validator.is);
         else if (validator.type === "validate")

package/src/programmers/PlainBodyProgrammer.ts

@@ -2,8 +2,9 @@ import ts from "typescript";
 
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/metadata/Metadata";
 import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
 
@@ -12,13 +13,16 @@ export namespace PlainBodyProgrammer {
         (project: INestiaTransformProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type): readonly ts.Expression[] => {
-            validate(
-                MetadataFactory.analyze(project.checker)({
-                    resolve: false,
-                    constant: true,
-                    absorb: true,
-                })(new MetadataCollection())(type),
-            );
+            const result = MetadataFactory.analyze(project.checker)({
+                escape: false,
+                constant: true,
+                absorb: true,
+                validate,
+            })(new MetadataCollection())(type);
+            if (result.success === false)
+                throw TransformerError.from("@core.nestia.TypedParam")(
+                    result.errors,
+                );
             return [
                 AssertProgrammer.write({
                     ...project,
@@ -32,22 +36,23 @@ export namespace PlainBodyProgrammer {
         };
 }
 
-const validate = (metadata: Metadata): void => {
+const validate = (metadata: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
     const expected: number =
-        (metadata.atomics.some((t) => t === "string") ? 1 : 0) +
+        (metadata.atomics.some((a) => a.type === "string") ? 1 : 0) +
         metadata.templates.length +
         metadata.constants
             .filter((c) => c.type === "string")
             .map((c) => c.values.length)
             .reduce((a, b) => a + b, 0);
     if (expected === 0 || expected !== metadata.size())
-        throw error(`only string type is allowed`);
-    else if (metadata.isRequired() === false)
-        throw error(`do not allow undefindable type`);
-    else if (metadata.nullable === true)
-        throw error(`do not allow nullable type`);
-    else if (metadata.any === true) throw error(`do not allow any type`);
-};
+        insert(`only string type is allowed`);
+    if (metadata.isRequired() === false)
+        insert(`do not allow undefindable type`);
+    if (metadata.nullable === true) insert(`do not allow nullable type`);
+    else if (metadata.any === true) insert(`do not allow any type`);
 
-const error = (msg: string) =>
-    new Error(`Error on nestia.core.PlainBody(): ${msg}.`);
+    return errors;
+};

package/src/programmers/TypedHeadersProgrammer.ts

@@ -4,15 +4,18 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { Metadata } from "typia/lib/metadata/Metadata";
-import { MetadataObject } from "typia/lib/metadata/MetadataObject";
-import { MetadataProperty } from "typia/lib/metadata/MetadataProperty";
 import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
 import { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { MetadataProperty } from "typia/lib/schemas/metadata/MetadataProperty";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
 import { Atomic } from "typia/lib/typings/Atomic";
 import { Escaper } from "typia/lib/utils/Escaper";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { CoreMetadataUtil } from "./internal/CoreMetadataUtil";
 
 export namespace TypedHeadersProgrammer {
     export const generate =
@@ -23,113 +26,101 @@ export namespace TypedHeadersProgrammer {
             return decode(project, modulo)(type, object);
         };
 
+    export const validate = (
+        meta: Metadata,
+        explore: MetadataFactory.IExplore,
+    ): string[] => {
+        const errors: string[] = [];
+        const insert = (msg: string) => errors.push(msg);
+
+        if (explore.top === true) {
+            // TOP MUST BE ONLY OBJECT
+            if (meta.objects.length !== 1 || meta.bucket() !== 1)
+                insert("only one object type is allowed.");
+            if (meta.nullable === true) insert("headers cannot be null.");
+            if (meta.isRequired() === false) insert("headers cannot be null.");
+        } else if (
+            explore.nested !== null &&
+            explore.nested instanceof MetadataArray
+        ) {
+            const atomics = CoreMetadataUtil.atomics(meta);
+            const expected: number =
+                meta.atomics.length +
+                meta.templates.length +
+                meta.constants
+                    .map((c) => c.values.length)
+                    .reduce((a, b) => a + b, 0);
+            if (atomics.size > 1) insert("union type is not allowed in array.");
+            if (meta.nullable) insert("nullable type is not allowed in array.");
+            if (meta.isRequired() === false)
+                insert("optional type is not allowed.");
+            if (meta.size() !== expected)
+                insert("only atomic or constant types are allowed in array.");
+        } else if (explore.object && explore.property !== null) {
+            //----
+            // COMMON
+            //----
+            // PROPERTY MUST BE SOLE
+            if (typeof explore.property === "object")
+                insert("dynamic property is not allowed.");
+            // MUST BE LOWER-CASE
+            if (
+                typeof explore.property === "string" &&
+                explore.property !== explore.property.toLowerCase()
+            )
+                insert("property name must be lower-case.");
+            // DO NOT ALLOW TUPLE TYPE
+            if (meta.tuples.length) insert("tuple type is not allowed.");
+            // DO NOT ALLOW UNION TYPE
+            if (CoreMetadataUtil.isUnion(meta))
+                insert("union type is not allowed.");
+            // DO NOT ALLOW NESTED OBJECT
+            if (
+                meta.objects.length ||
+                meta.sets.length ||
+                meta.maps.length ||
+                meta.natives.length
+            )
+                insert("nested object type is not allowed.");
+            // DO NOT ALLOW NULLABLE
+            if (meta.nullable) insert("nullable type is not allowed.");
+
+            //----
+            // ARRAY CASES
+            //----
+            const isArray: boolean = meta.arrays.length > 1;
+            // ARRAY TYPE MUST BE REQUIRED
+            if (isArray && meta.isRequired() === false)
+                insert("optional type is not allowed when array.");
+            // SET-COOKIE MUST BE ARRAY
+            if (explore.property === "set-cookie" && !isArray)
+                insert("set-cookie property must be array.");
+            // MUST BE SINGULAR CASE
+            if (
+                typeof explore.property === "string" &&
+                SINGULAR.has(explore.property) &&
+                isArray
+            )
+                insert("property cannot be array.");
+        }
+        return errors;
+    };
+
     const getObject =
         (checker: ts.TypeChecker) =>
         (type: ts.Type): MetadataObject => {
             const collection: MetadataCollection = new MetadataCollection();
-            const metadata: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
+            const result = MetadataFactory.analyze(checker)({
+                escape: false,
                 constant: true,
                 absorb: true,
+                validate,
             })(collection)(type);
-            if (metadata.objects.length !== 1 || metadata.bucket() !== 1)
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "only one object type is allowed.",
-                    ),
-                );
-            else if (metadata.nullable === true)
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "query parameter cannot be null.",
-                    ),
-                );
-            else if (metadata.isRequired() === false)
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "query parameter cannot be undefined.",
-                    ),
-                );
-
-            const object: MetadataObject = metadata.objects[0]!;
-            if (object.properties.some((p) => !(p.key as any).isSoleLiteral()))
-                throw new Error(
-                    ErrorMessages.object(metadata)(
-                        "dynamic property is not allowed.",
-                    ),
-                );
-
-            for (const property of object.properties) {
-                const key: string = property.key.constants[0]
-                    .values[0] as string;
-                const value: Metadata = property.value;
-                validate(object)(key)(value, 0);
-            }
-            return object;
-        };
-
-    const validate =
-        (obj: MetadataObject) =>
-        (key: string) =>
-        (value: Metadata, depth: number): string[] => {
-            if (depth === 1 && value.isRequired() === false)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "optional type is not allowed in array.",
-                    ),
-                );
-            else if (value.nullable === true)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "nullable type is not allowed.",
-                    ),
+            if (result.success === false)
+                throw TransformerError.from("@core.nestia.TypedHeaders")(
+                    result.errors,
                 );
-            else if (
-                value.maps.length ||
-                value.sets.length ||
-                value.objects.length
-            )
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "object type is not allowed",
-                    ),
-                );
-
-            const atom: string[] = [];
-            for (const type of value.atomics) atom.push(type);
-            for (const { type } of value.constants) atom.push(type);
-
-            if (depth === 0 && (value.arrays.length || value.arrays.length)) {
-                if (atom.length)
-                    throw new Error(
-                        ErrorMessages.property(obj)(key)(
-                            "union type is not allowed",
-                        ),
-                    );
-                for (const array of value.arrays)
-                    atom.push(...validate(obj)(key)(array.value, depth + 1));
-                for (const tuple of value.tuples)
-                    for (const elem of tuple.elements)
-                        atom.push(...validate(obj)(key)(elem, depth + 1));
-            } else if (value.arrays.length || value.tuples.length)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "double-array type is not allowed",
-                    ),
-                );
-
-            const size: number = new Set(atom).size;
-            if (size === 0)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)("unknown type"),
-                );
-            else if (size > 1)
-                throw new Error(
-                    ErrorMessages.property(obj)(key)(
-                        "union type is not allowed",
-                    ),
-                );
-            return atom;
+            return result.data.objects[0]!;
         };
 
     const decode =
@@ -156,7 +147,9 @@ export namespace TypedHeadersProgrammer {
             })(modulo)(false)(type);
             const output: ts.Identifier = ts.factory.createIdentifier("output");
 
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                "TypedHeaders",
+            );
             const statements: ts.Statement[] = [
                 StatementFactory.constant(
                     "output",
@@ -189,14 +182,15 @@ export namespace TypedHeadersProgrammer {
 
             const [type, isArray]: [Atomic.Literal, boolean] = value.atomics
                 .length
-                ? [value.atomics[0], false]
+                ? [value.atomics[0].type, false]
                 : value.constants.length
                 ? [value.constants[0]!.type, false]
                 : (() => {
                       const meta =
-                          value.arrays[0]?.value ?? value.tuples[0].elements[0];
+                          value.arrays[0]?.type.value ??
+                          value.tuples[0].type.elements[0];
                       return meta.atomics.length
-                          ? [meta.atomics[0], true]
+                          ? [meta.atomics[0].type, true]
                           : [meta.constants[0]!.type, true];
                   })();
             if (isArray && SINGULAR.has(key))