@nestjs/common 12.1.1 → 12.1.3

package/decorators/core/inject.decorator.js

@@ -44,7 +44,10 @@ export function Inject(token) {
             return;
         }
         let properties = Reflect.getMetadata(PROPERTY_DEPS_METADATA, target.constructor) || [];
-        properties = [...properties, { key, type }];
+        properties = [
+            ...properties.filter(property => property.key !== key),
+            { key, type },
+        ];
         Reflect.defineMetadata(PROPERTY_DEPS_METADATA, properties, target.constructor);
     };
 }

package/decorators/core/optional.decorator.js

@@ -20,7 +20,7 @@ export function Optional() {
             Reflect.defineMetadata(OPTIONAL_DEPS_METADATA, [...args, index], target);
             return;
         }
-        const properties = Reflect.getOwnMetadata(OPTIONAL_PROPERTY_DEPS_METADATA, target.constructor) || [];
+        const properties = Reflect.getMetadata(OPTIONAL_PROPERTY_DEPS_METADATA, target.constructor) || [];
         Reflect.defineMetadata(OPTIONAL_PROPERTY_DEPS_METADATA, [...properties, key], target.constructor);
     };
 }

package/decorators/http/create-route-param-metadata.decorator.js

@@ -24,8 +24,19 @@ export function createParamDecorator(factory, enhancers = []) {
         const hasParamData = isNil(data) || !isPipe(data);
         const paramData = hasParamData ? data : undefined;
         const paramPipes = hasParamData ? pipes : [data, ...pipes];
-        // Check if data itself is an options object (when used as the first argument)
-        const isDataOptions = hasParamData && !isNil(data) && isParameterDecoratorOptions(data);
+        // Custom data may also contain schema or pipes properties, so only treat
+        // the first argument as options when those are its only keys and their
+        // values, if defined, are a Standard Schema and an array of pipes.
+        const isDataOptions = hasParamData &&
+            !isNil(data) &&
+            isParameterDecoratorOptions(data) &&
+            Object.keys(data).every(key => key === 'schema' || key === 'pipes') &&
+            (data.schema === undefined ||
+                isFunction(data.schema?.['~standard']?.validate)) &&
+            (data.pipes === undefined ||
+                (Array.isArray(data.pipes) &&
+                    // Falsy entries are allowed, as the pipes context filters them out
+                    data.pipes.every(pipe => isNil(pipe) || isPipe(pipe))));
         // Check if the last pipe argument is actually an options object
         const lastPipeArg = paramPipes.length > 0 ? paramPipes[paramPipes.length - 1] : undefined;
         const isLastPipeOptions = !isDataOptions && isParameterDecoratorOptions(lastPipeArg);

package/file-stream/streamable-file.js

@@ -32,7 +32,10 @@ export class StreamableFile {
             this.stream = new Readable();
             this.stream.push(bufferOrReadStream);
             this.stream.push(null);
-            this.options.length ??= bufferOrReadStream.length;
+            this.options = {
+                ...this.options,
+                length: this.options.length ?? bufferOrReadStream.length,
+            };
         }
         else if (bufferOrReadStream.pipe && isFunction(bufferOrReadStream.pipe)) {
             this.stream = bufferOrReadStream;

package/interfaces/http/http-server.interface.d.ts

@@ -1,4 +1,5 @@
 import { RequestMethod } from '../../enums/index.js';
+import { RouteInfo } from '../middleware/middleware-configuration.interface.js';
 import { NestApplicationOptions } from '../../interfaces/nest-application-options.interface.js';
 import { VersionValue, VersioningOptions } from '../version-options.interface.js';
 import { CookieSerializeOptions } from './cookie-options.interface.js';
@@ -419,8 +420,14 @@ export interface HttpServer<TRequest = any, TResponse = any, ServerInstance = an
      *
      * @param handler The `(req, res, next)` callback.
      * @param prefix The global prefix (`app.setGlobalPrefix()`), when set.
-     */
-    setNotFoundHandler?(handler: Function, prefix?: string): any;
+     * @param excludedRoutes The routes `app.setGlobalPrefix()` excluded from the
+     * prefix, when any. They live at the root, so an adapter that scopes the
+     * handler by `prefix` should also mount it on each of these paths, for
+     * every method: with `exclude: ['hello']` and only `GET /hello` declared,
+     * `POST /hello` is still an unmatched request for a route Nest owns. Paths
+     * arrive already converted to the framework's route syntax.
+     */
+    setNotFoundHandler?(handler: Function, prefix?: string, excludedRoutes?: RouteInfo[]): any;
     /**
      * Serves static files; pass-through for `app.useStaticAssets()`. The
      * arguments are platform-specific. When not implemented,

package/interfaces/nest-application-context.interface.d.ts

@@ -57,19 +57,19 @@ export interface INestApplicationContext {
     get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
     /**
      * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
+     * @returns {Promise<TResult>}
      */
     resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
     /**
      * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
+     * @returns {Promise<TResult>}
      */
     resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
         id: number;
     }): Promise<TResult>;
     /**
      * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
+     * @returns {Promise<TResult>}
      */
     resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
         id: number;
@@ -79,7 +79,7 @@ export interface INestApplicationContext {
     }): Promise<TResult>;
     /**
      * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
-     * @returns {Array<TResult>}
+     * @returns {Promise<Array<TResult>>}
      */
     resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
         id: number;

package/module-utils/utils/get-injection-providers.util.js

@@ -22,10 +22,11 @@ export function getInjectionProviders(providers, tokens) {
         const match = (providers ?? []).filter(p => !result.includes(p) && // this prevents circular loops and duplication
             (search.includes(p) || search.includes(p?.provide)));
         result.push(...match);
-        // get injection tokens of the matched providers, if any
+        // Follow factory dependencies and aliases to existing providers.
         search = match
-            .filter(p => p?.inject)
-            .flatMap(p => p.inject)
+            .flatMap(p => p?.useExisting !== undefined
+            ? [p.useExisting]
+            : (p?.inject ?? []))
             .map(mapInjectToTokens);
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/common",
-  "version": "12.1.1",
+  "version": "12.1.3",
   "description": "Nest - modern, fast, powerful node.js web framework (@common)",
   "author": "Kamil Mysliwiec",
   "homepage": "https://nestjs.com",
@@ -47,5 +47,5 @@
       "optional": true
     }
   },
-  "gitHead": "9feedffde8ef8c86f0cd521153740575dc579d88"
+  "gitHead": "4514623279f6087808e3c8f08fbf9f37d3c17482"
 }

package/pipes/file/file-type.validator.js

@@ -107,6 +107,9 @@ export class FileTypeValidator extends FileValidator {
         if (typeof fileType === 'string' && mimetype === fileType) {
             return true;
         }
-        return !!mimetype.match(fileType);
+        // Stateful expressions must start at zero for each file, without changing
+        // the caller's lastIndex (the validator can be reused across uploads).
+        const pattern = typeof fileType === 'string' ? fileType : new RegExp(fileType);
+        return !!mimetype.match(pattern);
     }
 }

package/pipes/parse-array.pipe.js

@@ -66,7 +66,9 @@ let ParseArrayPipe = class ParseArrayPipe {
             };
             const isExpectedTypePrimitive = this.isExpectedTypePrimitive();
             const toClassInstance = (item, index) => {
-                if (this.options.items !== String) {
+                // `JSON.parse` stringifies its argument first, so an array holding a
+                // single item (`[1]` becomes `'1'`) would be parsed as that item.
+                if (this.options.items !== String && isString(item)) {
                     try {
                         item = JSON.parse(item);
                     }

package/pipes/parse-uuid.pipe.d.ts

@@ -1,5 +1,9 @@
 import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface.js';
 import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util.js';
+/**
+ * @publicApi
+ */
+export type UUIDVersion = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 'all';
 /**
  * @publicApi
  */
@@ -7,7 +11,7 @@ export interface ParseUUIDPipeOptions {
     /**
      * UUID version to validate
      */
-    version?: '3' | '4' | '5' | '7';
+    version?: UUIDVersion;
     /**
      * The HTTP status code to be used in the response when the validation fails.
      */
@@ -34,16 +38,10 @@ export interface ParseUUIDPipeOptions {
  */
 export declare class ParseUUIDPipe implements PipeTransform {
     protected readonly options?: ParseUUIDPipeOptions | undefined;
-    protected static uuidRegExps: {
-        3: RegExp;
-        4: RegExp;
-        5: RegExp;
-        7: RegExp;
-        all: RegExp;
-    };
+    protected static uuidRegExps: Record<UUIDVersion, RegExp>;
     private readonly version;
     protected exceptionFactory: (errors: string) => any;
     constructor(options?: ParseUUIDPipeOptions | undefined);
     transform(value: unknown, metadata: ArgumentMetadata): Promise<string | undefined | null>;
-    protected isUUID(str: unknown, version?: string): any;
+    protected isUUID(str: unknown, version?: UUIDVersion): boolean;
 }

package/pipes/parse-uuid.pipe.js

@@ -16,10 +16,14 @@ let ParseUUIDPipe = class ParseUUIDPipe {
     static { ParseUUIDPipe_1 = this; }
     options;
     static uuidRegExps = {
+        1: /^[0-9A-F]{8}-[0-9A-F]{4}-1[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+        2: /^[0-9A-F]{8}-[0-9A-F]{4}-2[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
         3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
         4: /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
         5: /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+        6: /^[0-9A-F]{8}-[0-9A-F]{4}-6[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
         7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+        8: /^[0-9A-F]{8}-[0-9A-F]{4}-8[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
         // Versions 1-8 with the RFC variant, or the Nil and Max UUIDs (RFC 9562, sections 5.9, 5.10)
         all: /^(?:[0-9A-F]{8}-[0-9A-F]{4}-[1-8][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}|00000000-0000-0000-0000-000000000000|FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF)$/i,
     };
@@ -39,7 +43,7 @@ let ParseUUIDPipe = class ParseUUIDPipe {
             return value;
         }
         if (!this.isUUID(value, this.version)) {
-            throw this.exceptionFactory(`Validation failed (uuid${this.version ? ` v ${this.version}` : ''} is expected)`);
+            throw this.exceptionFactory(`Validation failed (uuid${this.version && this.version !== 'all' ? ` v ${this.version}` : ''} is expected)`);
         }
         return value;
     }

package/pipes/validation.pipe.js

@@ -216,18 +216,20 @@ let ValidationPipe = class ValidationPipe {
         return result;
     }
     mapChildrenToValidationErrors(error, parentPath) {
+        const currentError = parentPath
+            ? this.prependConstraintsWithParentProp(parentPath, error)
+            : error;
         if (!(error.children && error.children.length)) {
-            return [error];
+            return [currentError];
         }
-        const validationErrors = [];
+        const validationErrors = error.constraints
+            ? [currentError]
+            : [];
         parentPath = parentPath
             ? `${parentPath}.${error.property}`
             : error.property;
         for (const item of error.children) {
-            if (item.children && item.children.length) {
-                validationErrors.push(...this.mapChildrenToValidationErrors(item, parentPath));
-            }
-            validationErrors.push(this.prependConstraintsWithParentProp(parentPath, item));
+            validationErrors.push(...this.mapChildrenToValidationErrors(item, parentPath));
         }
         return validationErrors;
     }

package/utils/parameter-decorator-options.util.d.ts

@@ -8,6 +8,9 @@ import type { ParameterDecoratorOptions } from '../decorators/http/route-params.
  * arguments identically: a pipe instance that happens to expose a `schema` or
  * `pipes` property must never be mistaken for an options object.
  *
+ * `createParamDecorator` applies a stricter check to its first argument, since
+ * that argument may also be arbitrary custom data.
+ *
  * @internal
  */
 export declare function isParameterDecoratorOptions(value: unknown): value is ParameterDecoratorOptions;

package/utils/parameter-decorator-options.util.js

@@ -12,6 +12,9 @@ const isPipeLike = (value) => isFunction(value?.transform) ||
  * arguments identically: a pipe instance that happens to expose a `schema` or
  * `pipes` property must never be mistaken for an options object.
  *
+ * `createParamDecorator` applies a stricter check to its first argument, since
+ * that argument may also be arbitrary custom data.
+ *
  * @internal
  */
 export function isParameterDecoratorOptions(value) {