@nestia/core 2.1.8 → 2.2.0-dev.20231010

package/src/decorators/TypedQuery.ts

@@ -1,10 +1,28 @@
-import { ExecutionContext, createParamDecorator } from "@nestjs/common";
+import {
+    BadRequestException,
+    CallHandler,
+    Delete,
+    ExecutionContext,
+    Get,
+    NestInterceptor,
+    Patch,
+    Post,
+    Put,
+    UseInterceptors,
+    applyDecorators,
+    createParamDecorator,
+} from "@nestjs/common";
+import { HttpArgumentsHost } from "@nestjs/common/interfaces";
 import type express from "express";
 import type { FastifyRequest } from "fastify";
+import { catchError, map } from "rxjs";
 
 import typia from "typia";
 
 import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
+import { IResponseBodyQuerifier } from "../options/IResponseBodyQuerifier";
+import { get_path_and_querify } from "./internal/get_path_and_querify";
+import { route_error } from "./internal/route_error";
 import { validate_request_query } from "./internal/validate_request_query";
 
 /**
@@ -44,6 +62,111 @@ export function TypedQuery<T extends object>(
         return output;
     })();
 }
+export namespace TypedQuery {
+    export function Body<T extends object>(
+        validator?: IRequestQueryValidator<T>,
+    ): ParameterDecorator {
+        const checker = validate_request_query(validator);
+        return createParamDecorator(function TypedQueryBody(
+            _unknown: any,
+            context: ExecutionContext,
+        ) {
+            const request: express.Request | FastifyRequest = context
+                .switchToHttp()
+                .getRequest();
+            if (isApplicationQuery(request.headers["content-type"]) === false)
+                throw new BadRequestException(
+                    `Request body type is not "application/x-www-form-urlencoded".`,
+                );
+            const params: URLSearchParams =
+                request.body instanceof URLSearchParams
+                    ? request.body
+                    : (new FakeURLSearchParams(request.body) as any);
+
+            const output: T | Error = checker(params);
+            if (output instanceof Error) throw output;
+            return output;
+        })();
+    }
+    Object.assign(Body, typia.http.assertQuery);
+    Object.assign(Body, typia.http.isQuery);
+    Object.assign(Body, typia.http.validateQuery);
+
+    /**
+     * Router decorator function for the GET method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Get = Generator("Get");
+
+    /**
+     * Router decorator function for the POST method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Post = Generator("Post");
+
+    /**
+     * Router decorator function for the PATH method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Patch = Generator("Patch");
+
+    /**
+     * Router decorator function for the PUT method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Put = Generator("Put");
+
+    /**
+     * Router decorator function for the DELETE method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Delete = Generator("Delete");
+
+    /**
+     * @internal
+     */
+    function Generator(method: "Get" | "Post" | "Put" | "Patch" | "Delete") {
+        function route(path?: string | string[]): MethodDecorator;
+        function route<T>(
+            stringify?: IResponseBodyQuerifier<T>,
+        ): MethodDecorator;
+        function route<T>(
+            path: string | string[],
+            stringify?: IResponseBodyQuerifier<T>,
+        ): MethodDecorator;
+
+        function route(...args: any[]): MethodDecorator {
+            const [path, stringify] = get_path_and_querify(
+                `TypedQuery.${method}`,
+            )(...args);
+            return applyDecorators(
+                ROUTERS[method](path),
+                UseInterceptors(new TypedQueryRouteInterceptor(stringify)),
+            );
+        }
+        return route;
+    }
+    for (const method of [typia.assert, typia.is, typia.validate])
+        for (const [key, value] of Object.entries(method))
+            for (const deco of [
+                TypedQuery.Get,
+                TypedQuery.Delete,
+                TypedQuery.Post,
+                TypedQuery.Put,
+                TypedQuery.Patch,
+            ])
+                (deco as any)[key] = value;
+}
 Object.assign(TypedQuery, typia.http.assertQuery);
 Object.assign(TypedQuery, typia.http.isQuery);
 Object.assign(TypedQuery, typia.http.validateQuery);
@@ -55,3 +178,76 @@ function tail(url: string): string {
     const index: number = url.indexOf("?");
     return index === -1 ? "" : url.substring(index + 1);
 }
+
+/**
+ * @internal
+ */
+function isApplicationQuery(text?: string): boolean {
+    return (
+        text !== undefined &&
+        text
+            .split(";")
+            .map((str) => str.trim())
+            .some((str) => str === "application/x-www-form-urlencoded")
+    );
+}
+
+/**
+ * @internal
+ */
+class FakeURLSearchParams {
+    public constructor(private readonly target: Record<string, string[]>) {}
+
+    public has(key: string): boolean {
+        return this.target[key] !== undefined;
+    }
+
+    public get(key: string): string | null {
+        const value = this.target[key];
+        return value === undefined
+            ? null
+            : Array.isArray(value)
+            ? value[0] ?? null
+            : value;
+    }
+
+    public getAll(key: string): string[] {
+        const value = this.target[key];
+        return value === undefined
+            ? []
+            : Array.isArray(value)
+            ? value
+            : [value];
+    }
+}
+
+/**
+ * @internal
+ */
+class TypedQueryRouteInterceptor implements NestInterceptor {
+    public constructor(
+        private readonly toSearchParams: (input: any) => URLSearchParams,
+    ) {}
+
+    public intercept(context: ExecutionContext, next: CallHandler) {
+        const http: HttpArgumentsHost = context.switchToHttp();
+        const response: express.Response = http.getResponse();
+        response.header("Content-Type", "application/x-www-form-urlencoded");
+
+        return next.handle().pipe(
+            map((value) => this.toSearchParams(value).toString()),
+            catchError((err) => route_error(http.getRequest(), err)),
+        );
+    }
+}
+
+/**
+ * @internal
+ */
+const ROUTERS = {
+    Get,
+    Post,
+    Patch,
+    Put,
+    Delete,
+};

package/src/decorators/internal/get_path_and_querify.ts

@@ -0,0 +1,104 @@
+import { InternalServerErrorException } from "@nestjs/common";
+
+import typia, { IValidation, TypeGuardError } from "typia";
+
+import { IResponseBodyQuerifier } from "../../options/IResponseBodyQuerifier";
+import { NoTransformConfigureError } from "./NoTransformConfigureError";
+
+/**
+ * @internal
+ */
+export const get_path_and_querify =
+    (method: string) =>
+    (
+        ...args: any[]
+    ): [string | string[] | undefined, (input: any) => URLSearchParams] => {
+        const path: string | string[] | null | undefined =
+            args[0] === undefined ||
+            typeof args[0] === "string" ||
+            Array.isArray(args[0])
+                ? args[0]
+                : null;
+        const functor: IResponseBodyQuerifier<any> | undefined =
+            path === null ? args[0] : args[1];
+        return [path ?? undefined, take(method)(functor)];
+    };
+
+/**
+ * @internal
+ */
+const take =
+    (method: string) =>
+    <T>(functor?: IResponseBodyQuerifier<T> | null) => {
+        if (functor === undefined) throw NoTransformConfigureError(method);
+        else if (functor === null) return querify;
+        else if (functor.type === "stringify") return functor.stringify;
+        else if (functor.type === "assert") return assert(functor.assert);
+        else if (functor.type === "is") return is(functor.is);
+        else if (functor.type === "validate") return validate(functor.validate);
+        throw new Error(
+            `Error on nestia.core.${method}(): invalid typed stringify function.`,
+        );
+    };
+
+const querify = (input: Record<string, any>): URLSearchParams => {
+    const output: URLSearchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(input))
+        if (key === undefined) continue;
+        else if (Array.isArray(value))
+            for (const elem of value) output.append(key, String(elem));
+        else output.append(key, String(value));
+    return output;
+};
+
+/**
+ * @internal
+ */
+const assert =
+    <T>(closure: (data: T) => URLSearchParams) =>
+    (data: T) => {
+        try {
+            return closure(data);
+        } catch (exp) {
+            if (typia.is<TypeGuardError>(exp))
+                throw new InternalServerErrorException({
+                    path: exp.path,
+                    reason: exp.message,
+                    expected: exp.expected,
+                    value: exp.value,
+                    message: MESSAGE,
+                });
+            throw exp;
+        }
+    };
+
+/**
+ * @internal
+ */
+const is =
+    <T>(closure: (data: T) => URLSearchParams | null) =>
+    (data: T) => {
+        const result: URLSearchParams | null = closure(data);
+        if (result === null) throw new InternalServerErrorException(MESSAGE);
+        return result;
+    };
+
+/**
+ * @internal
+ */
+const validate =
+    <T>(closure: (data: T) => IValidation<URLSearchParams>) =>
+    (data: T) => {
+        const result: IValidation<URLSearchParams> = closure(data);
+        if (result.success === false)
+            throw new InternalServerErrorException({
+                errors: result.errors,
+                message: MESSAGE,
+            });
+        return result.data;
+    };
+
+/**
+ * @internal
+ */
+const MESSAGE = "Response body data is not following the promised type.";

package/src/options/IResponseBodyQuerifier.ts

@@ -0,0 +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>;
+    }
+}

package/src/programmers/TypedQueryBodyProgrammer.ts

@@ -0,0 +1,52 @@
+import ts from "typescript";
+
+import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
+import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
+import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
+
+export namespace TypedQueryBodyProgrammer {
+    export const generate =
+        (project: INestiaTransformProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type): ts.ObjectLiteralExpression => {
+            // GENERATE VALIDATION PLAN
+            const parameter =
+                (key: IRequestQueryValidator<any>["type"]) =>
+                (
+                    programmer: (
+                        project: IProject,
+                    ) => (
+                        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({
+                                ...project,
+                                options: {
+                                    numeric: false,
+                                    finite: false,
+                                    functional: false,
+                                },
+                            })(modulo)(type),
+                        ),
+                    ]);
+
+            // RETURNS
+            const category = project.options.validate;
+            if (category === "is" || category === "equals")
+                return parameter("is")(HttpIsQueryProgrammer.write);
+            else if (category === "validate" || category === "validateEquals")
+                return parameter("validate")(HttpValidateQueryProgrammer.write);
+            return parameter("assert")(HttpAssertQueryProgrammer.write);
+        };
+}

package/src/programmers/TypedQueryRouteProgrammer.ts

@@ -0,0 +1,55 @@
+import ts from "typescript";
+
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformProject } 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 =
+        (project: INestiaTransformProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type): ts.Expression => {
+            // GENERATE STRINGIFY PLAN
+            const parameter = (
+                key: string,
+                programmer: (
+                    project: IProject,
+                ) => (
+                    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({
+                            ...project,
+                            options: {}, // use default option
+                        })(modulo)(type),
+                    ),
+                ]);
+
+            // RETURNS
+            if (project.options.stringify === "is")
+                return parameter("is", HttpIsQuerifyProgrammer.write);
+            else if (project.options.stringify === "validate")
+                return parameter(
+                    "validate",
+                    HttpValidateQuerifyProgrammer.write,
+                );
+            else if (project.options.stringify === "stringify")
+                return parameter("stringify", HttpQuerifyProgrammer.write);
+            else if (project.options.stringify === null)
+                return ts.factory.createNull();
+
+            // ASSERT IS DEFAULT
+            return parameter("assert", HttpAssertQuerifyProgrammer.write);
+        };
+}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts

@@ -0,0 +1,59 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpAssertQuerifyProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "stringify",
+                        HttpQuerifyProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("stringify"),
+                            undefined,
+                            [
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("assert"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ],
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpIsQuerifyProgrammer.ts

@@ -0,0 +1,63 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+
+export namespace HttpIsQuerifyProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type),
+                    ),
+                    StatementFactory.constant(
+                        "stringify",
+                        HttpQuerifyProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createConditionalExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            undefined,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("stringify"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            undefined,
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpQuerifyProgrammer.ts

@@ -0,0 +1,105 @@
+import ts from "typescript";
+
+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 { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
+import { HttpQueryProgrammer } from "typia/lib/programmers/http/HttpQueryProgrammer";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataObject } from "typia/lib/schemas/metadata/MetadataObject";
+import { IProject } from "typia/lib/transformers/IProject";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+export namespace HttpQuerifyProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type): ts.ArrowFunction => {
+            // GET OBJECT TYPE
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
+            const collection: MetadataCollection = new MetadataCollection();
+            const result = MetadataFactory.analyze(project.checker)({
+                escape: false,
+                constant: true,
+                absorb: true,
+                validate: HttpQueryProgrammer.validate,
+            })(collection)(type);
+            if (result.success === false)
+                throw TransformerError.from(
+                    `@nestia.core.TypedQuery.${importer.method}`,
+                )(result.errors);
+
+            const object: MetadataObject = result.data.objects[0]!;
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock(
+                    [
+                        ...importer.declare(modulo),
+                        StatementFactory.constant(
+                            "output",
+                            ts.factory.createNewExpression(
+                                ts.factory.createIdentifier("URLSearchParams"),
+                                undefined,
+                                [],
+                            ),
+                        ),
+                        ...object.properties.map((p) =>
+                            ts.factory.createExpressionStatement(
+                                decode(p.key.constants[0]!.values[0] as string)(
+                                    p.value,
+                                ),
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createIdentifier("output"),
+                        ),
+                    ],
+                    true,
+                ),
+            );
+        };
+
+    const decode =
+        (key: string) =>
+        (value: Metadata): ts.CallExpression =>
+            !!value.arrays.length
+                ? ts.factory.createCallExpression(
+                      IdentifierFactory.access(
+                          IdentifierFactory.access(
+                              ts.factory.createIdentifier("input"),
+                          )(key),
+                      )("forEach"),
+                      undefined,
+                      [
+                          ts.factory.createArrowFunction(
+                              undefined,
+                              undefined,
+                              [IdentifierFactory.parameter("elem")],
+                              undefined,
+                              undefined,
+                              append(key)(ts.factory.createIdentifier("elem")),
+                          ),
+                      ],
+                  )
+                : append(key)(
+                      IdentifierFactory.access(
+                          ts.factory.createIdentifier("input"),
+                      )(key),
+                  );
+
+    const append = (key: string) => (elem: ts.Expression) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.access(ts.factory.createIdentifier("output"))(
+                "append",
+            ),
+            undefined,
+            [ts.factory.createStringLiteral(key), elem],
+        );
+}