Redux Toolkit createSlice name uniqueness: missing global constraint

Direct Answers

Enforcement mechanisms: Redux Toolkit provides no built-in global constraint for slice names. To enforce uniqueness, you must implement external safeguards such as a custom ESLint rule, a build-time AST scanner, or a centralized registry pattern that throws an error during initialization.

Lint/build-time detection: Yes, this is reliable for string literals. A lint rule or script can traverse the Abstract Syntax Tree (AST) to collect all name properties passed to createSlice and flag duplicates. Detection is less reliable if names are generated dynamically at runtime.

Retroactive rename impact: Yes, changing a slice name alters all generated action type strings (e.g., "counter/increment" becomes "user/increment"). This will break any middleware, persisted state (localStorage/IndexedDB), or analytics logs that rely on matching those specific strings.

The Collision Mechanism

Redux Toolkit generates action types using the pattern [sliceName]/[reducerName]. Because the library does not maintain a global registry of these names, two different slices named "auth" will both produce an action type of "auth/logout". When this action is dispatched, every reducer associated with that string will execute, potentially corrupting state across unrelated features.

Implementation Strategies

1. Static Analysis (Build-Time)

The most scalable approach is a script that scans the codebase before deployment. Using a tool like @babel/parser, you can identify CallExpression nodes where the callee is createSlice and verify the name argument.

2. Centralized Name Registry (Runtime)

For teams preferring runtime safety, create a wrapper function to manage names:

const registeredSlices = new Set();

export function registerSliceName(name) {
  if (registeredSlices.has(name)) {
    throw new Error(`Redux Toolkit Collision: Slice name "${name}" is already in use.`);
  }
  registeredSlices.add(name);
  return name;
}

// Usage
const userSlice = createSlice({
  name: registerSliceName('user'),
  reducers: { ... }
});

3. Namespace Conventions

In monorepos, enforce a naming convention that includes the feature or package name (e.g., "billing/invoice" instead of just "invoice") to reduce the probability of collisions.

Verification and Safety

• Audit: Search the bundled JavaScript output for the pattern "/[a-zA-Z0-9_]+" to identify all generated action types and check for duplicates.
• Middleware Check: If renaming a slice, grep the codebase for the old string prefix to ensure no useEffect or middleware logic is hardcoded to the old action type.
• Persistence: If using redux-persist, verify that renaming a slice does not lead to orphaned state in the user's browser storage.

Missing Diagnostic Detail

Are your slice names defined as static string literals or are they derived from environment variables/dynamic constants? Static literals can be caught by linting, while dynamic names require the runtime registry approach.