@nestia/core 1.4.4 → 1.4.6

package/src/decorators/TypedQuery.ts

@@ -17,13 +17,20 @@ import { TransformError } from "./internal/TransformError";
  * same with {@link nest.Query}, but it can automatically cast property type following
  * its DTO definition. Also, `TypedQuery` performs type validation.
  *
- * For referecen, when URL query parameters are different with their promised
- * type `T`, `BadRequestException` error (status code: 400) would be thrown.
+ * For reference, target type `T` must follw such restriction. Also, if actual URL
+ * query parameter values are different with their promised type `T`,
+ * `BadRequestException` error (status code: 400) would be thrown.
+ *
+ * 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
  *
  * @returns Parameter decorator
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function TypedQuery<T>(
+export function TypedQuery<T extends object>(
     decoder?: (params: URLSearchParams) => T,
 ): ParameterDecorator {
     if (decoder === undefined) throw TransformError("TypedQuery");

package/src/decorators/TypedRoute.ts

@@ -29,13 +29,14 @@ import { route_error } from "./internal/route_error";
  * Type safe router decorator functions.
  *
  * `TypedRoute` is a module containing router decorator functions which can boost up
- * JSON string conversion speed about 50x times faster than `class-transformer`.
+ * JSON string conversion speed about 200x times faster than `class-transformer`.
  * Furthermore, such JSON string conversion is even type safe through
  * [typia](https://github.com/samchon/typia).
  *
- * For reference, router functions of `TypedRoute` can convert custom error classes to
- * the regular {@link nest.HttpException} class automatically, through
- * {@link ExceptionManager}.
+ * For reference, if you try to invalid data that is not following the promised
+ * type `T`, 500 internal server error would be thrown. Also, as `TypedRoute` composes
+ * JSON string through `typia.assertStringify<T>()` function, it is not possible to
+ * modify response data through interceptors.
  *
  * @author Jeongho Nam - https://github.com/samchon
  */

package/src/module.ts

@@ -6,6 +6,7 @@ export * from "./decorators/EncryptedRoute";
 export * from "./utils/ExceptionManager";
 export * from "./decorators/PlainBody";
 export * from "./decorators/TypedBody";
+export * from "./decorators/TypedHeaders";
 export * from "./decorators/TypedParam";
 export * from "./decorators/TypedRoute";
 export * from "./decorators/TypedQuery";

package/src/programmers/TypedHeadersProgrammer.ts

@@ -0,0 +1,304 @@
+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 { 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 { Atomic } from "typia/lib/typings/Atomic";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace TypedHeadersProgrammer {
+    export const generate =
+        (project: INestiaTransformProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type): ts.Expression => {
+            const object: MetadataObject = getObject(project.checker)(type);
+            return decode(project, modulo)(type, object);
+        };
+
+    const getObject =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type): MetadataObject => {
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadata: Metadata = MetadataFactory.analyze(checker)({
+                resolve: false,
+                constant: true,
+                absorb: true,
+            })(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.",
+                    ),
+                );
+            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;
+        };
+
+    const decode =
+        (project: INestiaTransformProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, object: MetadataObject): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                decode_object(project, modulo)(type, object),
+            );
+
+    const decode_object =
+        (project: INestiaTransformProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, object: MetadataObject): ts.ConciseBody => {
+            const assert: ts.ArrowFunction = AssertProgrammer.write({
+                ...project,
+                options: {
+                    numeric: true,
+                    finite: true,
+                },
+            })(modulo)(false)(type);
+            const output: ts.Identifier = ts.factory.createIdentifier("output");
+
+            const importer: FunctionImporter = new FunctionImporter();
+            const statements: ts.Statement[] = [
+                StatementFactory.constant(
+                    "output",
+                    ts.factory.createObjectLiteralExpression(
+                        object.properties.map((prop) =>
+                            decode_regular_property(importer)(object)(prop),
+                        ),
+                        true,
+                    ),
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(assert, undefined, [
+                        output,
+                    ]),
+                ),
+            ];
+
+            return ts.factory.createBlock(
+                [...importer.declare(modulo), ...statements],
+                true,
+            );
+        };
+
+    const decode_regular_property =
+        (importer: FunctionImporter) =>
+        (object: MetadataObject) =>
+        (property: MetadataProperty): ts.PropertyAssignment => {
+            const key: string = property.key.constants[0]!.values[0] as string;
+            const value: Metadata = property.value;
+
+            const [type, isArray]: [Atomic.Literal, boolean] = value.atomics
+                .length
+                ? [value.atomics[0], false]
+                : value.constants.length
+                ? [value.constants[0]!.type, false]
+                : (() => {
+                      const meta =
+                          value.arrays[0]?.value ?? value.tuples[0].elements[0];
+                      return meta.atomics.length
+                          ? [meta.atomics[0], true]
+                          : [meta.constants[0]!.type, true];
+                  })();
+            if (key.toLowerCase() !== key)
+                throw new Error(
+                    ErrorMessages.property(object)(key)(
+                        `property "${key}" must be lower case.`,
+                    ),
+                );
+            else if (isArray && SINGULAR.has(key))
+                throw new Error(
+                    ErrorMessages.property(object)(key)(
+                        `property "${key}" cannot be array.`,
+                    ),
+                );
+            else if (!isArray && key === "set-cookie")
+                throw new Error(
+                    ErrorMessages.property(object)(key)(
+                        `property "${key}" must be array.`,
+                    ),
+                );
+
+            const accessor = IdentifierFactory.access(
+                ts.factory.createIdentifier("input"),
+            )(key);
+
+            return ts.factory.createPropertyAssignment(
+                Escaper.variable(key)
+                    ? key
+                    : ts.factory.createStringLiteral(key),
+                isArray
+                    ? key === "set-cookie"
+                        ? accessor
+                        : ts.factory.createCallChain(
+                              ts.factory.createPropertyAccessChain(
+                                  ts.factory.createCallChain(
+                                      ts.factory.createPropertyAccessChain(
+                                          accessor,
+                                          ts.factory.createToken(
+                                              ts.SyntaxKind.QuestionDotToken,
+                                          ),
+                                          ts.factory.createIdentifier("split"),
+                                      ),
+                                      undefined,
+                                      undefined,
+                                      [
+                                          ts.factory.createStringLiteral(
+                                              key === "cookie" ? "; " : ", ",
+                                          ),
+                                      ],
+                                  ),
+                                  ts.factory.createToken(
+                                      ts.SyntaxKind.QuestionDotToken,
+                                  ),
+                                  ts.factory.createIdentifier("map"),
+                              ),
+                              undefined,
+                              undefined,
+                              [importer.use(type)],
+                          )
+                    : decode_value(importer)(type)(accessor),
+            );
+        };
+
+    const decode_value =
+        (importer: FunctionImporter) =>
+        (type: Atomic.Literal) =>
+        (value: ts.Expression) =>
+            type === "string"
+                ? value
+                : ts.factory.createCallExpression(
+                      importer.use(type),
+                      undefined,
+                      [value],
+                  );
+}
+
+namespace ErrorMessages {
+    export const object = (type: Metadata) => (message: string) =>
+        `Error on nestia.core.TypedHeaders<${type.getName()}>(): ${message}`;
+
+    export const property =
+        (obj: MetadataObject) => (key: string) => (message: string) =>
+            `Error on nestia.core.TypedHeaders<${obj.name}>(): property "${key}" - ${message}`;
+}
+
+const SINGULAR: Set<string> = new Set([
+    "age",
+    "authorization",
+    "content-length",
+    "content-type",
+    "etag",
+    "expires",
+    "from",
+    "host",
+    "if-modified-since",
+    "if-unmodified-since",
+    "last-modified",
+    "location",
+    "max-forwards",
+    "proxy-authorization",
+    "referer",
+    "retry-after",
+    "server",
+    "user-agent",
+]);

package/src/programmers/TypedQueryProgrammer.ts

@@ -10,6 +10,7 @@ import { MetadataProperty } from "typia/lib/metadata/MetadataProperty";
 import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
 import { FunctionImporter } from "typia/lib/programmers/helpers/FunctionImporeter";
 import { Atomic } from "typia/lib/typings/Atomic";
+import { Escaper } from "typia/lib/utils/Escaper";
 
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
 
@@ -50,9 +51,17 @@ export namespace TypedQueryProgrammer {
                     ),
                 );
 
-            const object = metadata.objects[0]!;
+            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: Metadata = property.key;
+                const key: string = property.key.constants[0]
+                    .values[0] as string;
                 const value: Metadata = property.value;
                 validate(object)(key)(value, 0);
             }
@@ -61,7 +70,7 @@ export namespace TypedQueryProgrammer {
 
     const validate =
         (obj: MetadataObject) =>
-        (key: Metadata) =>
+        (key: string) =>
         (value: Metadata, depth: number): string[] => {
             if (depth === 1 && value.isRequired() === false)
                 throw new Error(
@@ -91,12 +100,6 @@ export namespace TypedQueryProgrammer {
                             "union type is not allowed",
                         ),
                     );
-                else if (value.isRequired() === false)
-                    throw new Error(
-                        ErrorMessages.property(obj)(key)(
-                            "array type cannot be optional",
-                        ),
-                    );
                 for (const array of value.arrays)
                     atom.push(...validate(obj)(key)(array.value, depth + 1));
                 for (const tuple of value.tuples)
@@ -145,21 +148,41 @@ export namespace TypedQueryProgrammer {
                     finite: true,
                 },
             })(modulo)(false)(type);
-            const output = ts.factory.createIdentifier("output");
+            const output: ts.Identifier = ts.factory.createIdentifier("output");
 
-            const importer = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter();
+            const optionalArrays: string[] = [];
             const statements: ts.Statement[] = [
                 StatementFactory.constant(
                     "output",
                     ts.factory.createObjectLiteralExpression(
-                        object.properties
-                            .filter((prop) => (prop.key as any).isSoleLiteral())
-                            .map((prop) =>
-                                decode_regular_property(importer)(prop),
-                            ),
+                        object.properties.map((prop) => {
+                            if (
+                                !prop.value.isRequired() &&
+                                prop.value.arrays.length +
+                                    prop.value.tuples.length >
+                                    0
+                            )
+                                optionalArrays.push(
+                                    prop.key.constants[0]!.values[0] as string,
+                                );
+                            return decode_regular_property(importer)(prop);
+                        }),
                         true,
                     ),
                 ),
+                ...optionalArrays.map((key) => {
+                    const access = IdentifierFactory.access(output)(key);
+                    return ts.factory.createIfStatement(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createNumericLiteral(0),
+                            IdentifierFactory.access(access)("length"),
+                        ),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createDeleteExpression(access),
+                        ),
+                    );
+                }),
                 ts.factory.createReturnStatement(
                     ts.factory.createCallExpression(assert, undefined, [
                         output,
@@ -192,7 +215,9 @@ export namespace TypedQueryProgrammer {
                           : [meta.constants[0]!.type, true];
                   })();
             return ts.factory.createPropertyAssignment(
-                key,
+                Escaper.variable(key)
+                    ? key
+                    : ts.factory.createStringLiteral(key),
                 isArray
                     ? ts.factory.createCallExpression(
                           IdentifierFactory.access(
@@ -240,8 +265,6 @@ namespace ErrorMessages {
         `Error on nestia.core.TypedQuery<${type.getName()}>(): ${message}`;
 
     export const property =
-        (obj: MetadataObject) => (key: Metadata) => (message: string) =>
-            `Error on nestia.core.TypedQuery<${
-                obj.name
-            }>(): property ${key.getName()} - ${message}`;
+        (obj: MetadataObject) => (key: string) => (message: string) =>
+            `Error on nestia.core.TypedQuery<${obj.name}>(): property "${key}" - ${message}`;
 }

package/src/transformers/ParameterDecoratorTransformer.ts

@@ -4,6 +4,7 @@ import ts from "typescript";
 import { INestiaTransformProject } from "../options/INestiaTransformProject";
 import { PlainBodyProgrammer } from "../programmers/PlainBodyProgrammer";
 import { TypedBodyProgrammer } from "../programmers/TypedBodyProgrammer";
+import { TypedHeadersProgrammer } from "../programmers/TypedHeadersProgrammer";
 import { TypedParamProgrammer } from "../programmers/TypedParamProgrammer";
 import { TypedQueryProgrammer } from "../programmers/TypedQueryProgrammer";
 
@@ -78,6 +79,10 @@ const FUNCTORS: Record<string, Programmer> = {
         parameters.length
             ? parameters
             : [TypedBodyProgrammer.generate(project)(modulo)(type)],
+    TypedHeaders: (project) => (modulo) => (parameters) => (type) =>
+        parameters.length
+            ? parameters
+            : [TypedHeadersProgrammer.generate(project)(modulo)(type)],
     TypedParam: (project) => () => TypedParamProgrammer.generate(project),
     TypedQuery: (project) => (modulo) => (parameters) => (type) =>
         parameters.length