Hey everyone,

I recently ran into a tricky issue while setting up the sample app on my Windows 11 machine using Node 24 and Docker Engine. When I tried running yarn run dev in the backend, I hit a snag with the RegExp route construction. Let's dive into the details and see what's going on.

The Problem: Unterminated Character Class Error

The error message I encountered was quite specific:

[01:59:45.909Z] INFO  API: Register route to '\:slugParts([^\_][^\]+)*'
[01:59:45.909Z] ERROR BROKER: Unable to start all services. SyntaxError: Invalid regular expression: /^\/\:slugParts((?:[^\_][^\]+)(?:\/(?:[^\_][^\]+))*)?(?:\/)?$/i: Unterminated character class

This error points to a problem within the regular expression used for route matching. Specifically, the issue lies in the tokensToRegExp function, which is responsible for converting route patterns into regular expressions. The error message "Unterminated character class" indicates that there's an issue with how the character classes (the parts within square brackets []) are defined in the regular expression.

To further understand the error, let’s break down the regular expression that’s causing the issue: /^\/\:slugParts((?:[^\_][^\]+)(?:\/(?:[^\_][^\]+))*)?(?:\/)?$/i

Regular expressions, or regex, are sequences of characters that define a search pattern. They are used to match character combinations in strings. In this case, the regex is being used to match URL paths.

The problematic part seems to be [^\_][^\]+]. This is a character class that tries to match any character that is not an underscore _ and not a backslash \. However, the backslash in the second character class [^\]+] is likely not being interpreted correctly, leading to the “Unterminated character class” error.

Diving Deep into the tokensToRegExp Function

The tokensToRegExp function, part of the popular path-to-regexp library, is used extensively in many Node.js frameworks and libraries for defining routes. It takes a route pattern (like /:slugParts) and converts it into a regular expression that can be used to match incoming URLs. This conversion process involves parsing the route pattern, identifying parameters, and constructing a regular expression that accurately captures the intended routing logic.

When constructing complex routes, the regular expressions can become quite intricate. The issue often arises when special characters (like backslashes) are not properly escaped or when character classes are not correctly terminated. In this particular case, the interaction between the negative character classes (using ^) and the special characters within those classes seems to be the root cause of the problem.

Possible Causes and the Node 24, Windows 11 Factor

The error suggests that there might be an encoding issue or a platform-specific problem. Here’s a breakdown of potential causes:

1. Encoding Issues: Different operating systems and environments might handle character encoding differently. This can lead to misinterpretations of special characters in the regular expression. For example, a backslash might be treated as a literal character in one environment but as an escape character in another.
2. Node.js Version: Node.js versions can have subtle differences in how they handle regular expressions. It’s possible that Node 24 has a different interpretation or a bug related to regular expression parsing that is surfacing this issue.
3. Operating System: Windows, in particular, has different path handling conventions compared to Linux or macOS. This could potentially affect how regular expressions that deal with paths are interpreted.
4. Library Version: The path-to-regexp library itself might have a version-specific bug. It’s worth checking if updating or downgrading the library version resolves the issue. However, given that this library is widely used and relatively stable, this is less likely but still worth considering.

Given that the user mentioned using Windows 11 and Node 24, it's plausible that a combination of these factors is at play. Windows-specific path handling, combined with how Node 24 interprets regular expressions, might be triggering this error.

Temporary Workaround: Catchall Regex Route

As a quick workaround, the user replaced the problematic regular expression with a catchall route ^*.$. This regular expression essentially matches any sequence of characters, allowing the application to proceed. While this is a viable temporary solution, it's not ideal for production as it bypasses the specific routing logic that was intended.

To clarify, the catchall regex route ^*.$ is a simple regular expression that matches any string. Here's how it works:

• ^: Matches the beginning of the string.
• *.: Matches any character (.) zero or more times (*).
• $: Matches the end of the string.

By using this, all routes are essentially directed to the same handler, which isn't the desired behavior for most applications. The correct fix would involve addressing the underlying issue in the original regex.

The Real Solution: Fixing the Regular Expression

The core of the problem lies in the regular expression and how it's being interpreted. To address this, we need to ensure that special characters are properly escaped and that the character classes are correctly defined.

Proper Escaping of Special Characters

In regular expressions, certain characters have special meanings (e.g., \, [, ], ^, $, ., *, +, ?, (, ), {, }, |). If you want to match these characters literally, you need to escape them using a backslash \. However, the backslash itself is a special character in many programming languages and string contexts, so it often needs to be escaped as well.

In this case, the backslash in [^\]+] is likely the culprit. It might not be correctly escaped, leading to the unterminated character class error. The correct way to escape a backslash within a character class in a regular expression is to use two backslashes \\.

Refining the Character Class

The original character class [^\_][^\]+] intends to match any character that is not an underscore and not a backslash. However, the way it's constructed might not be optimal. A better approach would be to combine these into a single character class: [^\_\\].

This revised character class [^\_\\] does the following:

• [^...]: Matches any character that is not inside the square brackets.
• \_: Matches a literal underscore.
• \\: Matches a literal backslash (the first backslash escapes the second).

By combining these into a single character class, we ensure that we're matching any character that is neither an underscore nor a backslash in a more concise and clear manner.

Proposed Solution

Given the analysis, the following adjustments should resolve the issue:

1. Modify the regular expression: Update the regular expression in the tokensToRegExp function to correctly escape the backslashes and refine the character classes.
2. Test the changes: After modifying the regex, thoroughly test the routing logic to ensure that it behaves as expected.

Specifically, the problematic part of the regex: /^\/\:slugParts((?:[^\_][^\]+)(?:\/(?:[^\_][^\]+))*)?(?:\/)?$/i

Should be updated to use the corrected character class. A possible corrected regex could look like this (though it might need further adjustments based on the exact requirements):

/^\/\:slugParts((?:[^\_\\]+)(?:\/(?:[^\_\\]+))*)?(?:\/)?$/i

In this updated regex, [^\_\\] is used, which correctly matches any character that is not an underscore or a backslash.

Applying the Fix in Code

To apply this fix, you would need to locate the part of the code where the regular expression is being constructed, likely within the tokensToRegExp function or a related utility. Then, replace the problematic regex with the corrected version.

Here's a conceptual example of how you might apply the fix in JavaScript:

// Assuming the regex is constructed in a function like this
function constructRegex(routePattern) {
  // Original regex (problematic)
  // const regex = new RegExp(`^\/${routePattern}((?:[^\_][^\]+)(?:\/(?:[^\_][^\]+))*)?(?:\/)?


	
    
    
    
    
	
	
	
	
	
	
	
    
    
    
    
    
    
    
    
    
    


    

        
    
    

        




    


            

                

                    
RegExp Route Issue In TokensToRegExp Function: A Deep Dive
                    

                        Aug 9, 2025
                        by Luna Greco
                        
                            59 views
                        
                    
                
            
            

                


    

            
            

                

                    

  

    
    
  
                        , 'i');

  // Corrected regex
  const regex = new RegExp(`^\/${routePattern}((?:[^\_\\]+)(?:\/(?:[^\_\\]+))*)?(?:\/)?


	
    
    
    
    
	
	
	
	
	
	
	
    
    
    
    
    
    
    
    
    
    


    

        
    
    

        




    


            

                

                    
RegExp Route Issue In TokensToRegExp Function: A Deep Dive
                    

                        Aug 9, 2025
                        by Luna Greco
                        
                            59 views
                        
                    
                
            
            

                


    

            
            

                

                    

  

    
    
  
                        , 'i);
  return regex;
}