refactor: extract resolveAdapters utility and add regression tests

Author: RomainLanz

commands/queue_work.ts

@@ -8,6 +8,7 @@
  */
 
 import { flags, BaseCommand } from '@adonisjs/core/ace'
+import { resolveAdapters } from '../src/utils.js'
 import type { CommandOptions } from '@adonisjs/core/types/ace'
 import type { QueueConfig } from '../src/types/main.js'
 
@@ -38,19 +39,7 @@ export default class QueueWork extends BaseCommand {
     const router = await this.app.container.make('router')
     router.commit()
 
-    /**
-     * Resolve adapter factories from config providers
-     */
-    const resolvedAdapters: Record<string, () => any> = {}
-
-    for (const [name, adapterConfig] of Object.entries(config.adapters)) {
-      if (typeof adapterConfig === 'function') {
-        resolvedAdapters[name] = adapterConfig as () => any
-      } else {
-        resolvedAdapters[name] = await adapterConfig.resolver(this.app)
-      }
-    }
-
+    const resolvedAdapters = await resolveAdapters(config, this.app)
     const queues = this.queue ? this.queue.split(',').map((q) => q.trim()) : ['default']
 
     this.logger.info(`Starting worker for queues: ${queues.join(', ')}`)

providers/queue_provider.ts

@@ -8,6 +8,7 @@
  */
 
 import '../src/types/extended.js'
+import { resolveAdapters } from '../src/utils.js'
 import type { ApplicationService } from '@adonisjs/core/types'
 import type { QueueConfig } from '../src/types/main.js'
 
@@ -19,18 +20,7 @@ export default class QueueProvider {
       const { QueueManager } = await import('@boringnode/queue')
       const config = this.app.config.get<QueueConfig>('queue')
 
-      /**
-       * Resolve adapter factories from config providers
-       */
-      const resolvedAdapters: Record<string, () => any> = {}
-
-      for (const [name, adapterConfig] of Object.entries(config.adapters)) {
-        if (typeof adapterConfig === 'function') {
-          resolvedAdapters[name] = adapterConfig as () => any
-        } else {
-          resolvedAdapters[name] = await adapterConfig.resolver(this.app)
-        }
-      }
+      const resolvedAdapters = await resolveAdapters(config, this.app)
 
       /**
        * Inject jobFactory if not already defined.

src/utils.ts

@@ -0,0 +1,39 @@
+/*
+ * @adonisjs/queue
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ApplicationService } from '@adonisjs/core/types'
+import type { QueueConfig } from './types/main.js'
+
+type AdapterFactory = () => any
+
+/**
+ * Resolve adapter factories from config providers.
+ *
+ * Adapters in the config can be either:
+ * - Direct factory functions
+ * - ConfigProvider objects that need to be resolved
+ *
+ * This function normalizes them all to factory functions.
+ */
+export async function resolveAdapters(
+  config: QueueConfig,
+  app: ApplicationService
+): Promise<Record<string, AdapterFactory>> {
+  const resolvedAdapters: Record<string, AdapterFactory> = {}
+
+  for (const [name, adapterConfig] of Object.entries(config.adapters)) {
+    if (typeof adapterConfig === 'function') {
+      resolvedAdapters[name] = adapterConfig as AdapterFactory
+    } else {
+      resolvedAdapters[name] = await adapterConfig.resolver(app)
+    }
+  }
+
+  return resolvedAdapters
+}

tests/utils.spec.ts

@@ -0,0 +1,165 @@
+/*
+ * @adonisjs/queue
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { test } from '@japa/runner'
+import { IgnitorFactory } from '@adonisjs/core/factories'
+
+import { defineConfig, drivers } from '../index.js'
+import { resolveAdapters } from '../src/utils.js'
+import type { QueueConfig } from '../src/types/main.js'
+
+const BASE_URL = new URL('./tmp/', import.meta.url)
+
+test.group('resolveAdapters', () => {
+  test('should resolve config providers to adapter factories', async ({ assert }) => {
+    const ignitor = new IgnitorFactory()
+      .withCoreProviders()
+      .withCoreConfig()
+      .merge({
+        config: {
+          queue: defineConfig({
+            default: 'sync',
+            adapters: {
+              sync: drivers.sync(),
+            },
+          }),
+        },
+        rcFileContents: {
+          providers: [() => import('../providers/queue_provider.js')],
+        },
+      })
+      .create(BASE_URL, {
+        importer: (filePath) => {
+          if (filePath.startsWith('./') || filePath.startsWith('../')) {
+            return import(new URL(filePath, BASE_URL).href)
+          }
+
+          return import(filePath)
+        },
+      })
+
+    const app = ignitor.createApp('console')
+    await app.init().then(() => app.boot())
+
+    const config = app.config.get<QueueConfig>('queue')
+
+    /**
+     * Before resolution, the adapter is a ConfigProvider (object with resolver method)
+     */
+    assert.isObject(config.adapters.sync)
+    assert.isFunction((config.adapters.sync as any).resolver)
+
+    /**
+     * After resolution, the adapter should be a factory function
+     */
+    const resolvedAdapters = await resolveAdapters(config, app)
+    assert.isFunction(resolvedAdapters.sync)
+
+    await app.terminate()
+  })
+
+  test('should pass through direct factory functions unchanged', async ({ assert }) => {
+    const directFactory = () => ({
+      pushOn: async () => {},
+      pushLaterOn: async () => {},
+      pop: async () => null,
+      acknowledge: async () => {},
+      fail: async () => {},
+      getFailedJobs: async () => [],
+      removeFailedJob: async () => {},
+      clearFailedJobs: async () => {},
+      destroy: async () => {},
+    })
+
+    const ignitor = new IgnitorFactory()
+      .withCoreProviders()
+      .withCoreConfig()
+      .merge({
+        config: {
+          queue: defineConfig({
+            default: 'custom',
+            adapters: {
+              custom: directFactory as any,
+            },
+          }),
+        },
+        rcFileContents: {
+          providers: [() => import('../providers/queue_provider.js')],
+        },
+      })
+      .create(BASE_URL, {
+        importer: (filePath) => {
+          if (filePath.startsWith('./') || filePath.startsWith('../')) {
+            return import(new URL(filePath, BASE_URL).href)
+          }
+
+          return import(filePath)
+        },
+      })
+
+    const app = ignitor.createApp('console')
+    await app.init().then(() => app.boot())
+
+    const config = app.config.get<QueueConfig>('queue')
+    const resolvedAdapters = await resolveAdapters(config, app)
+
+    assert.strictEqual(resolvedAdapters.custom, directFactory)
+
+    await app.terminate()
+  })
+
+  test('worker should accept resolved adapters without throwing', async ({ assert }) => {
+    const ignitor = new IgnitorFactory()
+      .withCoreProviders()
+      .withCoreConfig()
+      .merge({
+        config: {
+          queue: defineConfig({
+            default: 'sync',
+            adapters: {
+              sync: drivers.sync(),
+            },
+          }),
+        },
+        rcFileContents: {
+          providers: [() => import('../providers/queue_provider.js')],
+        },
+      })
+      .create(BASE_URL, {
+        importer: (filePath) => {
+          if (filePath.startsWith('./') || filePath.startsWith('../')) {
+            return import(new URL(filePath, BASE_URL).href)
+          }
+
+          return import(filePath)
+        },
+      })
+
+    const app = ignitor.createApp('console')
+    await app.init().then(() => app.boot())
+
+    const config = app.config.get<QueueConfig>('queue')
+    const resolvedAdapters = await resolveAdapters(config, app)
+
+    /**
+     * Creating a Worker with resolved adapters should not throw
+     * "Adapter must be a factory function" error
+     */
+    const { Worker } = await import('@boringnode/queue')
+
+    assert.doesNotThrow(() => {
+      new Worker({
+        ...config,
+        adapters: resolvedAdapters,
+      })
+    })
+
+    await app.terminate()
+  })
+})