@nestia/core 13.0.4 → 14.0.1

package/src/decorators/internal/EncryptedConstant.ts

@@ -1,2 +1,15 @@
-/** @internal */
+/**
+ * The password an {@link EncryptedModule} gives each controller it reaches.
+ *
+ * @internal
+ */
 export const ENCRYPTION_METADATA_KEY = "nestia:core:encryption:password";
+
+/**
+ * The password an {@link EncryptedController} declares for its own class, kept
+ * apart from the module's so that the module never replaces it.
+ *
+ * @internal
+ */
+export const ENCRYPTION_CONTROLLER_METADATA_KEY =
+  "nestia:core:encryption:controller-password";

package/src/decorators/internal/get_encryption_password.ts

@@ -0,0 +1,19 @@
+import { IEncryptionPassword } from "@nestia/fetcher";
+
+import {
+  ENCRYPTION_CONTROLLER_METADATA_KEY,
+  ENCRYPTION_METADATA_KEY,
+} from "./EncryptedConstant";
+
+/**
+ * The encryption password of a controller class. The password its own
+ * `@EncryptedController()` declares, which a subclass inherits, precedes the
+ * one an `EncryptedModule` gave it: the more specific declaration wins.
+ *
+ * @internal
+ */
+export const get_encryption_password = (
+  target: Function,
+): IEncryptionPassword | IEncryptionPassword.Closure | undefined =>
+  Reflect.getMetadata(ENCRYPTION_CONTROLLER_METADATA_KEY, target) ??
+  Reflect.getMetadata(ENCRYPTION_METADATA_KEY, target);

package/src/decorators/internal/get_path_and_querify.ts

@@ -3,13 +3,18 @@ import typia, { IValidation, TypeGuardError } from "typia";
 
 import { IResponseBodyQuerifier } from "../../options/IResponseBodyQuerifier";
 import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
+import type { TypedRoute } from "../TypedRoute";
 
 /** @internal */
 export const get_path_and_querify =
+  (logger: () => (log: TypedRoute.IValidateErrorLog) => void) =>
   (method: string) =>
   (
     ...args: any[]
-  ): [string | string[] | undefined, (input: any) => URLSearchParams] => {
+  ): [
+    string | string[] | undefined,
+    (input: any, method: string, path: string) => URLSearchParams,
+  ] => {
     const path: string | string[] | null | undefined =
       args[0] === undefined ||
       typeof args[0] === "string" ||
@@ -18,11 +23,12 @@ export const get_path_and_querify =
         : null;
     const functor: IResponseBodyQuerifier<any> | undefined =
       path === null ? args[0] : args[1];
-    return [path ?? undefined, take(method)(functor)];
+    return [path ?? undefined, take(logger)(method)(functor)];
   };
 
 /** @internal */
 const take =
+  (logger: () => (log: TypedRoute.IValidateErrorLog) => void) =>
   (method: string) =>
   <T>(functor?: IResponseBodyQuerifier<T> | null) => {
     if (functor === undefined) {
@@ -33,6 +39,8 @@ const take =
     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);
+    else if (functor.type === "validate.log")
+      return validateLog(logger)(functor.validate);
     throw new Error(
       `Error on nestia.core.${method}(): invalid typed stringify function.`,
     );
@@ -91,4 +99,23 @@ const validate =
   };
 
 /** @internal */
+/**
+ * `validate.log`: an invalid response is reported to the validate-error logger
+ * and sent as it is, as `@TypedRoute`'s JSON responses are.
+ */
+const validateLog =
+  (logger: () => (log: TypedRoute.IValidateErrorLog) => void) =>
+  <T>(closure: (data: T) => IValidation<URLSearchParams>) =>
+  (data: T, method: string, path: string): URLSearchParams => {
+    const result: IValidation<URLSearchParams> = closure(data);
+    if (result.success === true) return result.data;
+    logger()({
+      errors: result.errors,
+      method,
+      path,
+      data,
+    });
+    return querify(data as Record<string, any>);
+  };
+
 const MESSAGE = "Response body data is not following the promised type.";

package/src/decorators/internal/get_text_body.ts

@@ -5,10 +5,14 @@ import raw from "raw-body";
 /** @internal */
 export const get_text_body = async (
   request: express.Request | FastifyRequest,
-): Promise<string> =>
-  isExpressRequest(request)
-    ? (await raw(request)).toString("utf8")
-    : (request.body as string);
+): Promise<string> => {
+  if (isExpressRequest(request) === false) return request.body as string;
+  // a body parser the application registered, such as
+  // `app.useBodyParser("text")`, has already consumed the stream
+  if (typeof request.body === "string") return request.body;
+  if (Buffer.isBuffer(request.body)) return request.body.toString("utf8");
+  return (await raw(request)).toString("utf8");
+};
 
 /** @internal */
 const isExpressRequest = (

package/src/decorators/internal/group_entries.ts

@@ -0,0 +1,17 @@
+/**
+ * The entries of a `URLSearchParams` or `FormData` as a plain object: a key
+ * given once maps to its value, a repeated key to all of its values in order.
+ *
+ * @internal
+ */
+export const group_entries = <Value>(source: {
+  keys(): Iterable<string>;
+  getAll(key: string): Value[];
+}): Record<string, Value | Value[]> => {
+  const output: Record<string, Value | Value[]> = {};
+  for (const key of new Set(source.keys())) {
+    const values: Value[] = source.getAll(key);
+    output[key] = values.length === 1 ? values[0]! : values;
+  }
+  return output;
+};

package/src/decorators/internal/validate_request_form_data.ts

@@ -3,6 +3,7 @@ import typia, { IValidation, TypeGuardError } from "typia";
 
 import { IRequestFormDataProps } from "../../options/IRequestFormDataProps";
 import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
+import { group_entries } from "./group_entries";
 
 /** @internal */
 export const validate_request_form_data = <T>(
@@ -10,7 +11,8 @@ export const validate_request_form_data = <T>(
 ): ((value: FormData) => T | Error) => {
   if (!props) {
     NoTransformConfigurationError("TypedFormData.Body");
-    return (input: FormData) => Object.entries(input) as T;
+    // no transform: the fields and files as they arrived
+    return (input: FormData) => group_entries(input) as T;
   } else if (props.validator.type === "assert")
     return assert(props.validator.assert);
   else if (props.validator.type === "is") return is(props.validator.is);

package/src/decorators/internal/validate_request_headers.ts

@@ -10,8 +10,8 @@ export const validate_request_headers = <T>(
 ): ((input: Record<string, string | string[] | undefined>) => T | Error) => {
   if (!validator) {
     NoTransformConfigurationError("TypedHeaders");
-    return (input: Record<string, string | string[] | undefined>) =>
-      Object.entries(input) as T;
+    // no transform: the headers as they arrived
+    return (input: Record<string, string | string[] | undefined>) => input as T;
   } 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);

package/src/decorators/internal/validate_request_query.ts

@@ -3,6 +3,7 @@ import typia, { IValidation, TypeGuardError } from "typia";
 
 import { IRequestQueryValidator } from "../../options/IRequestQueryValidator";
 import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
+import { group_entries } from "./group_entries";
 
 /** @internal */
 export const validate_request_query =
@@ -10,8 +11,8 @@ export const validate_request_query =
   <T>(validator?: IRequestQueryValidator<T>) => {
     if (!validator) {
       NoTransformConfigurationError(method);
-      return (input: URLSearchParams) =>
-        Object.fromEntries(input.entries()) as T;
+      // no transform: the query as it arrived, repeated keys as arrays
+      return (input: URLSearchParams) => group_entries(input) as T;
     } 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);

package/src/options/IResponseBodyQuerifier.ts

@@ -4,7 +4,8 @@ export type IResponseBodyQuerifier<T> =
   | IResponseBodyquerifier.IStringify<T>
   | IResponseBodyquerifier.IIs<T>
   | IResponseBodyquerifier.IAssert<T>
-  | IResponseBodyquerifier.IValidate<T>;
+  | IResponseBodyquerifier.IValidate<T>
+  | IResponseBodyquerifier.IValidateLog<T>;
 export namespace IResponseBodyquerifier {
   export interface IStringify<T> {
     type: "stringify";
@@ -22,4 +23,8 @@ export namespace IResponseBodyquerifier {
     type: "validate";
     validate: (input: T) => IValidation<URLSearchParams>;
   }
+  export interface IValidateLog<T> {
+    type: "validate.log";
+    validate: (input: T) => IValidation<URLSearchParams>;
+  }
 }

package/src/utils/ExceptionManager.ts

@@ -14,18 +14,17 @@ import { Creator } from "../typings/Creator";
  * {@link EncryptedRoute} instead of the basic router decorator functions like
  * {@link nest.Get} or {@link nest.Post} and the API function throws a custom
  * error whose class has been {@link ExceptionManager.insert inserted} in this
- * `EntityManager`, the error would be automatically converted to the regular
+ * `ExceptionManager`, the error would be automatically converted to the regular
  * {@link nest.HttpException} instance by the {@link ExceptionManager.Closure}
  * function.
  *
  * Therefore, with this `ExceptionManager` and {@link TypedRoute} or
  * {@link EncryptedRoute}, you can manage your custom error classes much
- * systemtically. You can avoid 500 internal server error or hard coding
+ * systematically. You can avoid 500 internal server error or hard coding
  * implementation about the custom error classes.
  *
- * Below error classes are defaultly configured in this `ExceptionManager`
+ * Below error class is configured in this `ExceptionManager` by default.
  *
- * - `typia.TypeGuardError`
  * - `@nestia/fetcher.HttpError`
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -47,8 +46,13 @@ export namespace ExceptionManager {
     const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
     if (index !== -1) tuples.splice(index, 1);
 
-    tuples.push([creator, closure]);
-    tuples.sort(([x], [y]) => (x.prototype instanceof y ? -1 : 1));
+    // an error converts by the first class it is an instance of, so a class
+    // must precede every superclass of it: insert before the first one
+    const ancestor: number = tuples.findIndex(
+      ([registered]) => creator.prototype instanceof registered,
+    );
+    if (ancestor === -1) tuples.push([creator, closure]);
+    else tuples.splice(ancestor, 0, [creator, closure]);
   }
 
   /**

package/src/utils/SourceFinder.ts

@@ -18,7 +18,7 @@ export namespace SourceFinder {
     (input: string[]) =>
     async (closure: (location: string) => void): Promise<void> => {
       for (const pattern of input) {
-        for (const file of await _Glob(path.resolve(pattern))) {
+        for (const file of await _Glob(pattern)) {
           const stats: fs.Stats = await fs.promises.stat(file);
           if (stats.isDirectory() === true)
             await iterate(filter)(closure)(file);
@@ -41,9 +41,30 @@ export namespace SourceFinder {
       }
     };
 
+  /**
+   * Files and directories a path or glob pattern names.
+   *
+   * An existing path is taken literally, whatever characters it holds, as a
+   * directory such as `app [v2]` would otherwise read as a character class. For
+   * a pattern, the longest existing ancestor is the literal base and only the
+   * rest is globbed, with `/` separators, since glob reads a Windows backslash
+   * as an escape.
+   */
   const _Glob = async (pattern: string): Promise<string[]> => {
-    const matches = await glob(pattern);
-    return matches.map((str) => path.resolve(str));
+    const absolute: string = path.resolve(pattern);
+    if (fs.existsSync(absolute)) return [absolute];
+    let base: string = absolute;
+    while (fs.existsSync(base) === false) {
+      const parent: string = path.dirname(base);
+      if (parent === base) return [];
+      base = parent;
+    }
+    const rest: string = path
+      .relative(base, absolute)
+      .split(path.sep)
+      .join("/");
+    const matches: string[] = await glob(rest, { cwd: base });
+    return matches.map((str) => path.resolve(base, str));
   };
 }
 

package/src/utils/VersioningStrategy.ts

@@ -11,17 +11,31 @@ export namespace VersioningStrategy {
   ): Array<string | typeof VERSION_NEUTRAL> =>
     value === undefined ? [] : Array.isArray(value) ? value : [value];
 
+  /**
+   * Version path segments of a route, resolved as NestJS resolves them: the
+   * method's versions, else the controller's, else the default version, and no
+   * version at all is the unversioned path (#1735).
+   */
   export const merge =
     (config: IConfig | undefined) =>
-    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
+    (props: {
+      controller: Array<string | typeof VERSION_NEUTRAL> | undefined;
+      method: Array<string | typeof VERSION_NEUTRAL> | undefined;
+    }): string[] => {
       if (config === undefined) return [""];
-      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
-      const array: Array<string | typeof VERSION_NEUTRAL> =
-        set.size === 0 ? cast(config.defaultVersion) : Array.from(set);
-      return !!array?.length
-        ? array.map((x) =>
+      const chosen: Array<string | typeof VERSION_NEUTRAL> = props.method
+        ?.length
+        ? props.method
+        : props.controller?.length
+          ? props.controller
+          : cast(config.defaultVersion);
+      const unique: Array<string | typeof VERSION_NEUTRAL> = [
+        ...new Set(chosen),
+      ];
+      return unique.length
+        ? unique.map((x) =>
             typeof x === "symbol" ? "" : `${config.prefix}${x}`,
           )
-        : [];
+        : [""];
     };
 }

package/lib/transform.d.ts

@@ -1,10 +0,0 @@
-import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
-/**
- * `@nestia/core` ttsc plugin descriptor.
- *
- * `@nestia/sdk` is not a standalone plugin: its Go transform is declared here
- * as a `contributor` that ttsc statically links into this host binary, and only
- * when `@nestia/sdk` is actually resolvable from the project. A project
- * depending on `@nestia/core` alone never compiles any SDK transform code.
- */
-export default function createTtscPlugin(context: ITtscPluginFactoryContext): ITtscPlugin;

package/lib/transform.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createTtscPlugin;
-const node_module_1 = require("node:module");
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * `@nestia/core` ttsc plugin descriptor.
- *
- * `@nestia/sdk` is not a standalone plugin: its Go transform is declared here
- * as a `contributor` that ttsc statically links into this host binary, and only
- * when `@nestia/sdk` is actually resolvable from the project. A project
- * depending on `@nestia/core` alone never compiles any SDK transform code.
- */
-function createTtscPlugin(context) {
-    const requireFrom = (0, node_module_1.createRequire)(node_path_1.default.join(context.projectRoot, "package.json"));
-    const root = node_path_1.default.dirname(requireFrom.resolve("@nestia/core/package.json"));
-    return {
-        name: "@nestia/core",
-        source: node_path_1.default.resolve(root, "native", "cmd", "ttsc-nestia"),
-    };
-}
-//# sourceMappingURL=transform.js.map

package/lib/transform.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transform.js","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAG7B;;;;;;;GAOG;AACH,0BACE,OAAkC;IAElC,MAAM,WAAW,GAAG,IAAA,2BAAa,EAC/B,mBAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAC/C,CAAC;IACF,MAAM,IAAI,GAAW,mBAAI,CAAC,OAAO,CAC/B,WAAW,CAAC,OAAO,CAAC,2BAA2B,CAAC,CACjD,CAAC;IACF,OAAO;QACL,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,CAAC;KAC3D,CAAC;AACJ,CAAC"}

package/src/transform.ts

@@ -1,26 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
-
-/**
- * `@nestia/core` ttsc plugin descriptor.
- *
- * `@nestia/sdk` is not a standalone plugin: its Go transform is declared here
- * as a `contributor` that ttsc statically links into this host binary, and only
- * when `@nestia/sdk` is actually resolvable from the project. A project
- * depending on `@nestia/core` alone never compiles any SDK transform code.
- */
-export default function createTtscPlugin(
-  context: ITtscPluginFactoryContext,
-): ITtscPlugin {
-  const requireFrom = createRequire(
-    path.join(context.projectRoot, "package.json"),
-  );
-  const root: string = path.dirname(
-    requireFrom.resolve("@nestia/core/package.json"),
-  );
-  return {
-    name: "@nestia/core",
-    source: path.resolve(root, "native", "cmd", "ttsc-nestia"),
-  };
-}