Allowed RegExp in the Path

Author: sdangol

packages/commons/src/index.ts

@@ -22,6 +22,7 @@ export {
   isNullOrUndefined,
   isNumber,
   isRecord,
+  isRegExp,
   isStrictEqual,
   isString,
   isStringUndefinedNullEmpty,

packages/commons/src/typeUtils.ts

@@ -176,6 +176,25 @@ const isStringUndefinedNullEmpty = (value: unknown) => {
   return false;
 };
 
+/**
+ * Check if a Regular Expression
+ *
+ * @example
+ * ```typescript
+ * import { isRegExp } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = /^foo.+$/;
+ * if (isRegExp(value)) {
+ *   // value is a Regular Expression
+ * }
+ * ```
+ *
+ * @param value - The value to check
+ */
+const isRegExp = (value: unknown): value is RegExp => {
+  return value instanceof RegExp;
+};
+
 /**
  * Get the type of a value as a string.
  *
@@ -337,6 +356,7 @@ export {
   isNull,
   isNullOrUndefined,
   isStringUndefinedNullEmpty,
+  isRegExp,
   getType,
   isStrictEqual,
 };

packages/commons/tests/unit/typeUtils.test.ts

@@ -6,6 +6,7 @@ import {
   isNullOrUndefined,
   isNumber,
   isRecord,
+  isRegExp,
   isStrictEqual,
   isString,
   isStringUndefinedNullEmpty,
@@ -224,6 +225,30 @@ describe('Functions: typeUtils', () => {
     });
   });
 
+  describe('Function: isRegExp', () => {
+    it('returns true when the passed value is a Regular Expression', () => {
+      // Prepare
+      const value = /^hello.+$/;
+
+      // Act
+      const result = isRegExp(value);
+
+      // Assess
+      expect(result).toBe(true);
+    });
+
+    it('returns false when the passed value is not a Regular Expression', () => {
+      // Prepare
+      const value = 123;
+
+      // Act
+      const result = isRegExp(value);
+
+      // Assess
+      expect(result).toBe(false);
+    });
+  });
+
   describe('Function: getType', () => {
     it.each([
       {

packages/event-handler/src/rest/RouteHandlerRegistry.ts

@@ -11,6 +11,7 @@ import { ParameterValidationError } from './errors.js';
 import { Route } from './Route.js';
 import {
   compilePath,
+  getPathString,
   resolvePrefixedPath,
   validatePathPattern,
 } from './utils.js';
@@ -45,8 +46,8 @@ class RouteHandlerRegistry {
     }
 
     // Routes with more path segments are more specific
-    const aSegments = a.path.split('/').length;
-    const bSegments = b.path.split('/').length;
+    const aSegments = getPathString(a.path).split('/').length;
+    const bSegments = getPathString(b.path).split('/').length;
 
     return bSegments - aSegments;
   }
@@ -104,7 +105,7 @@ class RouteHandlerRegistry {
 
     const compiled = compilePath(route.path);
 
-    if (!/^[\w+/:-]+$/.test(compiled.path)) {
+    if (route.path instanceof RegExp) {
       if (this.#regexRoutes.has(route.id)) {
         this.#logger.warn(
           `Handler for method: ${route.method} and path: ${route.path} already exists. The previous handler will be replaced.`
@@ -227,7 +228,7 @@ class RouteHandlerRegistry {
   #processRoute(route: DynamicRoute, method: HttpMethod, path: Path) {
     if (route.method !== method) return;
 
-    const match = route.regex.exec(path);
+    const match = route.regex.exec(getPathString(path));
     if (!match) return;
 
     const params = match.groups || {};

packages/event-handler/src/rest/utils.ts

@@ -1,4 +1,8 @@
-import { isRecord, isString } from '@aws-lambda-powertools/commons/typeutils';
+import {
+  isRecord,
+  isRegExp,
+  isString,
+} from '@aws-lambda-powertools/commons/typeutils';
 import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
 import type {
   CompiledRoute,
@@ -15,13 +19,21 @@ import {
   UNSAFE_CHARS,
 } from './constants.js';
 
+export function getPathString(path: Path): string {
+  return isString(path) ? path : path.source.replace(/\\\//g, '/');
+}
+
 export function compilePath(path: Path): CompiledRoute {
   const paramNames: string[] = [];
 
-  const regexPattern = path.replace(PARAM_PATTERN, (_match, paramName) => {
-    paramNames.push(paramName);
-    return `(?<${paramName}>[${SAFE_CHARS}${UNSAFE_CHARS}\\w]+)`;
-  });
+  const pathString = getPathString(path);
+  const regexPattern = pathString.replace(
+    PARAM_PATTERN,
+    (_match, paramName) => {
+      paramNames.push(paramName);
+      return `(?<${paramName}>[${SAFE_CHARS}${UNSAFE_CHARS}\\w]+)`;
+    }
+  );
 
   const finalPattern = `^${regexPattern}$`;
 
@@ -36,9 +48,10 @@ export function compilePath(path: Path): CompiledRoute {
 export function validatePathPattern(path: Path): ValidationResult {
   const issues: string[] = [];
 
-  const matches = [...path.matchAll(PARAM_PATTERN)];
-  if (path.includes(':')) {
-    const expectedParams = path.split(':').length;
+  const pathString = getPathString(path);
+  const matches = [...pathString.matchAll(PARAM_PATTERN)];
+  if (pathString.includes(':')) {
+    const expectedParams = pathString.split(':').length;
     if (matches.length !== expectedParams - 1) {
       issues.push('Malformed parameter syntax. Use :paramName format.');
     }
@@ -200,13 +213,22 @@ export const composeMiddleware = (middleware: Middleware[]): Middleware => {
 /**
  * Resolves a prefixed path by combining the provided path and prefix.
  *
+ * The function returns a RegExp if any of the path or prefix is a RegExp.
+ * Otherwise, it returns a `/${string}` type value.
+ *
  * @param path - The path to resolve
  * @param prefix - The prefix to prepend to the path
  */
 export const resolvePrefixedPath = (path: Path, prefix?: Path): Path => {
-  if (prefix) {
-    if (!path.startsWith('/')) return `${prefix}/${path}`;
-    return path === '/' ? prefix : `${prefix}${path}`;
+  if (!prefix) return path;
+  if (isRegExp(prefix)) {
+    if (isRegExp(path)) {
+      return new RegExp(`${getPathString(prefix)}/${getPathString(path)}`);
+    }
+    return new RegExp(`${getPathString(prefix)}${path}`);
+  }
+  if (isRegExp(path)) {
+    return new RegExp(`${prefix}/${getPathString(path)}`);
   }
-  return path;
+  return `${prefix}${path}`.replace(/\/$/, '') as Path;
 };

packages/event-handler/src/types/rest.ts

@@ -64,7 +64,7 @@ type HttpMethod = keyof typeof HttpVerbs;
 
 type HttpStatusCode = (typeof HttpStatusCodes)[keyof typeof HttpStatusCodes];
 
-type Path = string;
+type Path = `/${string}` | RegExp;
 
 type RestRouteHandlerOptions = {
   handler: RouteHandler;
@@ -79,9 +79,10 @@ type RestRouteOptions = {
   middleware?: Middleware[];
 };
 
-type NextFunction =
-  () => // biome-ignore lint/suspicious/noConfusingVoidType: To ensure next function is awaited
-  Promise<HandlerResponse | void> | HandlerResponse | void;
+type NextFunction = () => // biome-ignore lint/suspicious/noConfusingVoidType: To ensure next function is awaited
+  | Promise<HandlerResponse | void>
+  | HandlerResponse
+  | void;
 
 type Middleware = (args: {
   reqCtx: RequestContext;

packages/event-handler/tests/unit/rest/Router/basic-routing.test.ts

@@ -200,15 +200,15 @@ describe('Class: Router - Basic Routing', () => {
   ])('routes %s %s to %s handler', async (path, method, expectedApi) => {
     // Prepare
     const app = new Router();
-    app.get('/files/.+', async () => ({ api: 'serveFile' }));
-    app.get('/files/.+', async () => ({ api: 'serveFileOverride' }));
-    app.get('/api/v\\d+/.*', async () => ({ api: 'apiVersioning' }));
-    app.get('/users/:userId/files/.+', async (reqCtx) => ({
+    app.get(/\/files\/.+/, async () => ({ api: 'serveFile' }));
+    app.get(/\/files\/.+/, async () => ({ api: 'serveFileOverride' }));
+    app.get(/\/api\/v\d+\/.*/, async () => ({ api: 'apiVersioning' }));
+    app.get(/\/users\/:userId\/files\/.+/, async (reqCtx) => ({
       api: `dynamicRegex${reqCtx.params.userId}`,
     }));
-    app.get('.+', async () => ({ api: 'getAnyRoute' }));
+    app.get(/.+/, async () => ({ api: 'getAnyRoute' }));
     app.route(async () => ({ api: 'catchAllUnmatched' }), {
-      path: '.*',
+      path: /.*/,
       method: [HttpVerbs.GET, HttpVerbs.POST],
     });
 

packages/event-handler/tests/unit/rest/utils.test.ts

@@ -577,13 +577,15 @@ describe('Path Utilities', () => {
       { path: '/test', prefix: '/prefix', expected: '/prefix/test' },
       { path: '/', prefix: '/prefix', expected: '/prefix' },
       { path: '/test', expected: '/test' },
-      { path: '.+', prefix: '/prefix', expected: '/prefix/.+' },
+      { path: /.+/, prefix: '/prefix', expected: /\/prefix\/.+/ },
+      { path: '/test', prefix: /\/prefix/, expected: /\/prefix\/test/ },
+      { path: /.+/, prefix: /\/prefix/, expected: /\/prefix\/.+/ },
     ])('resolves prefixed path', ({ path, prefix, expected }) => {
       // Prepare & Act
       const resolvedPath = resolvePrefixedPath(path as Path, prefix as Path);
 
       // Assert
-      expect(resolvedPath).toBe(expected);
+      expect(resolvedPath).toEqual(expected);
     });
   });
 });