fixes

Author: aidanhibbard

spec/utils/__snapshots__/generate-workers-entry-content.spec.ts.snap

@@ -1,16 +1,17 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`generate-workers-entry-content > matches snapshot for multiple workers and redis url 1`] = `
+exports[`generate-workers-entry-content > matches snapshot for multiple workers and redis config 1`] = `
 "
 import { fileURLToPath } from 'node:url'
 import { resolve as resolvePath } from 'node:path'
 import { consola } from 'consola'
 import { $workers } from '#processor-utils'
+import { resolveRedisConnection } from '#resolve-redis'
 
 // Initialize connection as early as possible so any imports that register
 // workers/queues have a valid connection available.
 const api = $workers()
-api.setConnection(new (await import("ioredis")).default("redis://localhost:6379"))
+api.setConnection(resolveRedisConnection({"host":"localhost","port":6379}))
 
 export async function createWorkersApp() {
 // Avoid EPIPE when stdout/stderr are closed by terminal (e.g., Ctrl+C piping)
@@ -108,17 +109,18 @@ export default { createWorkersApp }
 "
 `;
 
-exports[`generate-workers-entry-content > matches snapshot for single worker and undefined redis 1`] = `
+exports[`generate-workers-entry-content > matches snapshot for single worker and empty redis config 1`] = `
 "
 import { fileURLToPath } from 'node:url'
 import { resolve as resolvePath } from 'node:path'
 import { consola } from 'consola'
 import { $workers } from '#processor-utils'
+import { resolveRedisConnection } from '#resolve-redis'
 
 // Initialize connection as early as possible so any imports that register
 // workers/queues have a valid connection available.
 const api = $workers()
-api.setConnection(undefined)
+api.setConnection(resolveRedisConnection({}))
 
 export async function createWorkersApp() {
 // Avoid EPIPE when stdout/stderr are closed by terminal (e.g., Ctrl+C piping)

spec/utils/generate-redis-connection-expr.spec.ts

@@ -1,17 +1,31 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { generateRedisConnectionExpr } from '../../src/utils/generate-redis-connection-expr'
-
-// Helper: evaluate the generated expression in current process context
-function evalExpr(expr: string): unknown {
-  return eval(expr)
-}
+import { generateRedisConnectionExpr, getRedisConnectionImport } from '../../src/utils/generate-redis-connection-expr'
+import { resolveRedisConnection } from '../../src/runtime/server/utils/resolve-redis-connection'
 
 function clearEnvKey(key: string) {
   Reflect.deleteProperty(process.env, key)
 }
 
 describe('generateRedisConnectionExpr', () => {
-  const savedEnv: Record<string, string | undefined> = {}
+  it('wraps static config in a resolveRedisConnection call', () => {
+    const expr = generateRedisConnectionExpr('{"host":"10.0.0.1"}')
+    expect(expr).toBe('resolveRedisConnection({"host":"10.0.0.1"})')
+  })
+
+  it('handles empty config', () => {
+    const expr = generateRedisConnectionExpr('{}')
+    expect(expr).toBe('resolveRedisConnection({})')
+  })
+})
+
+describe('getRedisConnectionImport', () => {
+  it('returns an import statement with the given alias', () => {
+    expect(getRedisConnectionImport('#resolve-redis'))
+      .toBe('import { resolveRedisConnection } from \'#resolve-redis\'')
+  })
+})
+
+describe('resolveRedisConnection', () => {
   const envKeys = [
     'NUXT_REDIS_URL',
     'NUXT_REDIS_HOST',
@@ -22,6 +36,7 @@ describe('generateRedisConnectionExpr', () => {
     'NUXT_REDIS_LAZY_CONNECT',
     'NUXT_REDIS_CONNECT_TIMEOUT',
   ]
+  const savedEnv: Record<string, string | undefined> = {}
 
   beforeEach(() => {
     for (const key of envKeys) {
@@ -42,9 +57,7 @@ describe('generateRedisConnectionExpr', () => {
   })
 
   it('returns static config when no env vars are set', () => {
-    const staticRedis = JSON.stringify({ host: '10.0.0.1', port: 6380, password: 'secret', db: 2 })
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr) as Record<string, unknown>
+    const result = resolveRedisConnection({ host: '10.0.0.1', port: 6380, password: 'secret', db: 2 })
 
     expect(result).toEqual({
       host: '10.0.0.1',
@@ -57,21 +70,21 @@ describe('generateRedisConnectionExpr', () => {
     })
   })
 
-  it('returns NUXT_REDIS_URL when set at runtime', () => {
+  it('includes url in returned object when NUXT_REDIS_URL is set', () => {
     process.env.NUXT_REDIS_URL = 'redis://prod-host:6379/1'
-    const staticRedis = JSON.stringify({ host: '127.0.0.1', port: 6379 })
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr)
+    const result = resolveRedisConnection({ host: '127.0.0.1', port: 6379 })
 
-    expect(result).toBe('redis://prod-host:6379/1')
+    expect(result).toMatchObject({ url: 'redis://prod-host:6379/1' })
+    // Other options are still present alongside url
+    expect(result).toHaveProperty('host')
+    expect(result).toHaveProperty('port')
   })
 
-  it('returns static url when set in config and no env url', () => {
-    const staticRedis = JSON.stringify({ url: 'redis://config-host:6379/0', host: '127.0.0.1' })
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr)
+  it('includes url from static config when no env url is set', () => {
+    const result = resolveRedisConnection({ url: 'redis://config-host:6379/0', host: '127.0.0.1' })
 
-    expect(result).toBe('redis://config-host:6379/0')
+    expect(result).toMatchObject({ url: 'redis://config-host:6379/0' })
+    expect(result).toHaveProperty('host', '127.0.0.1')
   })
 
   it('env vars override individual static fields', () => {
@@ -81,9 +94,7 @@ describe('generateRedisConnectionExpr', () => {
     process.env.NUXT_REDIS_USERNAME = 'admin'
     process.env.NUXT_REDIS_DB = '5'
 
-    const staticRedis = JSON.stringify({ host: '10.0.0.1', port: 6380, password: 'build-pw', db: 2 })
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr) as Record<string, unknown>
+    const result = resolveRedisConnection({ host: '10.0.0.1', port: 6380, password: 'build-pw', db: 2 })
 
     expect(result).toEqual({
       host: '192.168.1.100',
@@ -98,11 +109,8 @@ describe('generateRedisConnectionExpr', () => {
 
   it('env vars partially override static fields', () => {
     process.env.NUXT_REDIS_HOST = 'new-host'
-    // port, password etc. not set in env
 
-    const staticRedis = JSON.stringify({ host: '10.0.0.1', port: 6380, password: 'build-pw', db: 2 })
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr) as Record<string, unknown>
+    const result = resolveRedisConnection({ host: '10.0.0.1', port: 6380, password: 'build-pw', db: 2 })
 
     expect(result).toMatchObject({
       host: 'new-host',
@@ -112,22 +120,18 @@ describe('generateRedisConnectionExpr', () => {
     })
   })
 
-  it('NUXT_REDIS_URL env takes priority over static url in config', () => {
+  it('NUXT_REDIS_URL env takes priority over static url', () => {
     process.env.NUXT_REDIS_URL = 'redis://env-host:6379'
-    const staticRedis = JSON.stringify({ url: 'redis://config-host:6379' })
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr)
+    const result = resolveRedisConnection({ url: 'redis://config-host:6379' })
 
-    expect(result).toBe('redis://env-host:6379')
+    expect(result).toMatchObject({ url: 'redis://env-host:6379' })
   })
 
   it('handles lazyConnect and connectTimeout from env', () => {
     process.env.NUXT_REDIS_LAZY_CONNECT = 'true'
     process.env.NUXT_REDIS_CONNECT_TIMEOUT = '5000'
 
-    const staticRedis = JSON.stringify({})
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr) as Record<string, unknown>
+    const result = resolveRedisConnection({})
 
     expect(result).toMatchObject({
       lazyConnect: true,
@@ -136,9 +140,7 @@ describe('generateRedisConnectionExpr', () => {
   })
 
   it('falls back to defaults when both static and env are empty', () => {
-    const staticRedis = JSON.stringify({})
-    const expr = generateRedisConnectionExpr(staticRedis)
-    const result = evalExpr(expr) as Record<string, unknown>
+    const result = resolveRedisConnection({})
 
     expect(result).toEqual({
       host: '127.0.0.1',
@@ -151,11 +153,27 @@ describe('generateRedisConnectionExpr', () => {
     })
   })
 
-  it('generated expression contains process.env references', () => {
-    const expr = generateRedisConnectionExpr('{}')
-    expect(expr).toContain('process.env.NUXT_REDIS_URL')
-    expect(expr).toContain('process.env.NUXT_REDIS_HOST')
-    expect(expr).toContain('process.env.NUXT_REDIS_PORT')
-    expect(expr).toContain('process.env.NUXT_REDIS_PASSWORD')
+  it('does not include url key when no url is provided', () => {
+    const result = resolveRedisConnection({ host: '10.0.0.1' })
+
+    expect(result).not.toHaveProperty('url')
+  })
+
+  it('preserves all options alongside url for setConnection', () => {
+    process.env.NUXT_REDIS_URL = 'redis://prod:6379'
+    process.env.NUXT_REDIS_PASSWORD = 'prod-pw'
+
+    const result = resolveRedisConnection({ host: '127.0.0.1', connectTimeout: 10000 })
+
+    expect(result).toEqual({
+      url: 'redis://prod:6379',
+      host: '127.0.0.1',
+      port: 6379,
+      password: 'prod-pw',
+      username: undefined,
+      db: 0,
+      lazyConnect: undefined,
+      connectTimeout: 10000,
+    })
   })
 })

spec/utils/generate-workers-entry-content.spec.ts

@@ -1,27 +1,37 @@
 import { describe, it, expect } from 'vitest'
 import { generateWorkersEntryContent } from '../../src/utils/generate-workers-entry-content'
+import { generateRedisConnectionExpr } from '../../src/utils/generate-redis-connection-expr'
 
 describe('generate-workers-entry-content', () => {
-  it('matches snapshot for single worker and undefined redis', () => {
+  it('matches snapshot for single worker and empty redis config', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
     const content = generateWorkersEntryContent(
       ['/path/to/worker.mjs'],
-      'undefined',
+      redisExpr,
     )
     expect(content).toMatchSnapshot()
   })
 
-  it('matches snapshot for multiple workers and redis url', () => {
+  it('matches snapshot for multiple workers and redis config', () => {
+    const redisExpr = generateRedisConnectionExpr(JSON.stringify({ host: 'localhost', port: 6379 }))
     const content = generateWorkersEntryContent(
       ['/app/server/workers/basic.ts', '/app/server/workers/hello.ts'],
-      'new (await import("ioredis")).default("redis://localhost:6379")',
+      redisExpr,
     )
     expect(content).toMatchSnapshot()
   })
 
+  it('generates entry that imports resolveRedisConnection', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
+    const content = generateWorkersEntryContent(['/path/to/worker.mjs'], redisExpr)
+    expect(content).toContain('import { resolveRedisConnection } from \'#resolve-redis\'')
+  })
+
   it('generates entry that parses --workers flag from process.argv', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
     const content = generateWorkersEntryContent(
       ['/path/to/worker.mjs'],
-      'undefined',
+      redisExpr,
     )
     expect(content).toContain('process.argv.find(a => typeof a === \'string\' && a.startsWith(\'--workers=\'))')
     expect(content).toContain('workersArg.split(\'=\')[1].split(\',\').map(s => s.trim()).filter(Boolean)')
@@ -30,36 +40,40 @@ describe('generate-workers-entry-content', () => {
   })
 
   it('generates entry that filters workers by name when --workers is set', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
     const content = generateWorkersEntryContent(
       ['/path/to/worker.mjs'],
-      'undefined',
+      redisExpr,
     )
     expect(content).toContain('selectedWorkers.includes(w.name)')
     expect(content).toContain('api.workers.filter(w => w && selectedWorkers.includes(w.name))')
   })
 
   it('generates entry that runs all workers when --workers is not set', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
     const content = generateWorkersEntryContent(
       ['/path/to/worker.mjs'],
-      'undefined',
+      redisExpr,
     )
     expect(content).toContain('(Array.isArray(api.workers) ? api.workers : [])')
   })
 
   it('generates entry that returns stop closing only workersToRun', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
     const content = generateWorkersEntryContent(
       ['/path/to/worker.mjs'],
-      'undefined',
+      redisExpr,
     )
     expect(content).toContain('workersToRun.map(w => w.close())')
     expect(content).toContain('closeRunningWorkers')
     expect(content).toContain('return { stop: closeRunningWorkers, workers: workersToRun }')
   })
 
   it('generates entry that warns and exits when no workers match --workers filter', () => {
+    const redisExpr = generateRedisConnectionExpr('{}')
     const content = generateWorkersEntryContent(
       ['/path/to/worker.mjs'],
-      'undefined',
+      redisExpr,
     )
     expect(content).toContain('selectedWorkers && workersToRun.length === 0')
     expect(content).toContain('logger.warn')

src/module.ts

@@ -5,7 +5,7 @@ import type { Plugin } from 'rollup'
 import { relative } from 'node:path'
 import scanFolder from './utils/scan-folder'
 import { generateWorkersEntryContent } from './utils/generate-workers-entry-content'
-import { generateRedisConnectionExpr } from './utils/generate-redis-connection-expr'
+import { generateRedisConnectionExpr, getRedisConnectionImport } from './utils/generate-redis-connection-expr'
 
 // Module options TypeScript interface definition
 type ModuleRedisOptions = BullRedisOptions & { url?: string }
@@ -47,9 +47,12 @@ export default defineNuxtModule<ModuleOptions>({
     const staticRedis = JSON.stringify(_options.redis ?? {})
     const redisConnectionExpr = generateRedisConnectionExpr(staticRedis)
 
+    const redisImport = getRedisConnectionImport('#resolve-redis')
+
     const nitroPlugin = `
     import { defineNitroPlugin } from '#imports'
     import { $workers } from '#processor-utils'
+    ${redisImport}
 
     export default defineNitroPlugin(() => {
       $workers().setConnection(${redisConnectionExpr})
@@ -69,6 +72,7 @@ export default defineNuxtModule<ModuleOptions>({
     nuxt.options.alias['nuxt-processor'] = resolve('./runtime/server/handlers')
     nuxt.options.alias['#processor'] = resolve('./runtime/server/handlers')
     nuxt.options.alias['#processor-utils'] = resolve('./runtime/server/utils/workers')
+    nuxt.options.alias['#resolve-redis'] = resolve('./runtime/server/utils/resolve-redis-connection')
     // Allow swapping BullMQ implementation allowing for bullmq pro (default to 'bullmq')
     if (!nuxt.options.alias['#bullmq']) {
       nuxt.options.alias['#bullmq'] = 'bullmq'
@@ -92,6 +96,10 @@ declare module '#processor-utils' {
   export { $workers } from '${resolve('./runtime/server/utils/workers')}'
 }
 
+declare module '#resolve-redis' {
+  export { resolveRedisConnection } from '${resolve('./runtime/server/utils/resolve-redis-connection')}'
+}
+
 declare module '#bullmq' {
   export * from 'bullmq'
 }

src/runtime/server/utils/resolve-redis-connection.ts

@@ -0,0 +1,27 @@
+/**
+ * Resolves Redis connection options at runtime.
+ *
+ * Environment variables take precedence over the static config snapshot
+ * captured at build time. Returns an object with all options preserved,
+ * including `url` when applicable, so `setConnection` can pass them
+ * all to the IORedis constructor.
+ */
+export function resolveRedisConnection(
+  staticConfig: Record<string, unknown>,
+): Record<string, unknown> {
+  const url = process.env.NUXT_REDIS_URL ?? staticConfig.url
+  return {
+    ...(url ? { url } : {}),
+    host: process.env.NUXT_REDIS_HOST ?? staticConfig.host ?? '127.0.0.1',
+    port: Number(process.env.NUXT_REDIS_PORT ?? staticConfig.port ?? 6379),
+    password: process.env.NUXT_REDIS_PASSWORD ?? staticConfig.password ?? '',
+    username: process.env.NUXT_REDIS_USERNAME ?? staticConfig.username ?? undefined,
+    db: Number(process.env.NUXT_REDIS_DB ?? staticConfig.db ?? 0),
+    lazyConnect: process.env.NUXT_REDIS_LAZY_CONNECT
+      ? process.env.NUXT_REDIS_LAZY_CONNECT === 'true'
+      : (staticConfig.lazyConnect as boolean | undefined),
+    connectTimeout: process.env.NUXT_REDIS_CONNECT_TIMEOUT
+      ? Number(process.env.NUXT_REDIS_CONNECT_TIMEOUT)
+      : (staticConfig.connectTimeout as number | undefined),
+  }
+}