Address review comments

Author: kibertoad

packages/core/lib/types/queueOptionsTypes.ts

@@ -145,14 +145,13 @@ export type DeletionConfig = {
  * - Service B needs to subscribe to Service A's topic
  * - Neither can deploy first without the other's topic existing
  *
- * With `resourceAvailabilityConfig.enabled = true`, the consumer will poll for the
+ * When `resourceAvailabilityConfig` is provided, the consumer will poll for the
  * topic/queue to become available instead of failing immediately.
  *
  * @example
  * // Development/staging - poll indefinitely
  * {
  *   resourceAvailabilityConfig: {
- *     enabled: true,
  *     pollingIntervalMs: 5000,
  *   }
  * }
@@ -161,19 +160,27 @@ export type DeletionConfig = {
  * // Production - poll with timeout to catch misconfigurations
  * {
  *   resourceAvailabilityConfig: {
- *     enabled: true,
  *     timeoutMs: 5 * 60 * 1000, // 5 minutes
  *     pollingIntervalMs: 10000,
  *   }
  * }
+ *
+ * @example
+ * // Temporarily disable without removing config
+ * {
+ *   resourceAvailabilityConfig: {
+ *     enabled: false,
+ *     timeoutMs: 5 * 60 * 1000,
+ *   }
+ * }
  */
 export type ResourceAvailabilityConfig = {
   /**
-   * If true, the consumer will poll for the topic/queue to become available
-   * instead of failing immediately when using locatorConfig.
-   * Default: false (fail immediately for backwards compatibility)
+   * Controls whether polling is enabled.
+   * Default: true (when resourceAvailabilityConfig is provided)
+   * Set to false to temporarily disable polling without removing the config.
    */
-  enabled: boolean
+  enabled?: boolean
 
   /**
    * Maximum time in milliseconds to wait for the resource to become available.

packages/core/lib/utils/resourceAvailabilityUtils.spec.ts

@@ -11,6 +11,12 @@ describe('resourceAvailabilityUtils', () => {
       expect(isResourceAvailabilityWaitingEnabled({ enabled: true })).toBe(true)
     })
 
+    it('returns true when enabled is not specified (defaults to true)', () => {
+      expect(isResourceAvailabilityWaitingEnabled({})).toBe(true)
+      expect(isResourceAvailabilityWaitingEnabled({ pollingIntervalMs: 1000 })).toBe(true)
+      expect(isResourceAvailabilityWaitingEnabled({ timeoutMs: 5000 })).toBe(true)
+    })
+
     it('returns false when enabled is false', () => {
       expect(isResourceAvailabilityWaitingEnabled({ enabled: false })).toBe(false)
     })

packages/core/lib/utils/resourceAvailabilityUtils.ts

@@ -156,10 +156,11 @@ export async function waitForResource<T>(options: WaitForResourceOptions<T>): Pr
 }
 
 /**
- * Helper to check if resource availability waiting is enabled
+ * Helper to check if resource availability waiting is enabled.
+ * Returns true when config is provided and enabled is not explicitly false.
  */
 export function isResourceAvailabilityWaitingEnabled(
   config?: ResourceAvailabilityConfig,
 ): config is ResourceAvailabilityConfig {
-  return config?.enabled === true
+  return config != null && config.enabled !== false
 }

packages/sns/lib/utils/snsInitter.ts

@@ -151,7 +151,7 @@ export async function initSnsSqs(
       throw new Error(`Queue with queueUrl ${queueUrl} does not exist.`)
     }
     if (topicCheckResult?.error === 'not_found') {
-      throw new Error(`Topic with topicArn ${locatorConfig.topicArn} does not exist.`)
+      throw new Error(`Topic with topicArn ${subscriptionTopicArn} does not exist.`)
     }
   }
 
@@ -288,7 +288,7 @@ export async function initSns(
       // Original behavior: check once and fail immediately if not found
       const checkResult = await getTopicAttributes(snsClient, topicArn)
       if (checkResult.error === 'not_found') {
-        throw new Error(`Topic with topicArn ${locatorConfig.topicArn} does not exist.`)
+        throw new Error(`Topic with topicArn ${topicArn} does not exist.`)
       }
     }
 

packages/sns/test/consumers/SnsSqsPermissionConsumer.resourceAvailability.spec.ts

@@ -2,12 +2,18 @@ import { setTimeout } from 'node:timers/promises'
 import type { SNSClient } from '@aws-sdk/client-sns'
 import type { SQSClient } from '@aws-sdk/client-sqs'
 import type { STSClient } from '@aws-sdk/client-sts'
-import { ResourceAvailabilityTimeoutError } from '@message-queue-toolkit/core'
+import {
+  MessageHandlerConfigBuilder,
+  ResourceAvailabilityTimeoutError,
+} from '@message-queue-toolkit/core'
 import { assertQueue, deleteQueue } from '@message-queue-toolkit/sqs'
 import type { AwilixContainer } from 'awilix'
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import type { SNSSQSConsumerDependencies } from '../../lib/sns/AbstractSnsSqsConsumer.ts'
-import { AbstractSnsSqsConsumer } from '../../lib/sns/AbstractSnsSqsConsumer.ts'
+import {
+  AbstractSnsSqsConsumer,
+  type SNSSQSConsumerDependencies,
+  type SNSSQSConsumerOptions,
+} from '../../lib/sns/AbstractSnsSqsConsumer.ts'
 import { assertTopic, deleteTopic } from '../../lib/utils/snsUtils.ts'
 import type { Dependencies } from '../utils/testContext.ts'
 import { registerDependencies } from '../utils/testContext.ts'
@@ -16,42 +22,24 @@ import {
   type PERMISSIONS_ADD_MESSAGE_TYPE,
 } from './userConsumerSchemas.ts'
 
+type TestConsumerOptions = Pick<
+  SNSSQSConsumerOptions<PERMISSIONS_ADD_MESSAGE_TYPE, undefined, undefined>,
+  'locatorConfig' | 'creationConfig' | 'resourceAvailabilityConfig'
+>
+
 // Simple consumer for testing resource availability
 class TestResourceAvailabilityConsumer extends AbstractSnsSqsConsumer<
   PERMISSIONS_ADD_MESSAGE_TYPE,
   undefined,
   undefined
 > {
-  constructor(
-    dependencies: SNSSQSConsumerDependencies,
-    options: {
-      locatorConfig?: {
-        topicArn?: string
-        topicName?: string
-        queueUrl?: string
-        queueName?: string
-        subscriptionArn?: string
-      }
-      creationConfig?: {
-        queue?: { QueueName: string }
-        topic?: { Name: string }
-      }
-      resourceAvailabilityConfig?: {
-        enabled: boolean
-        timeoutMs?: number
-        pollingIntervalMs?: number
-      }
-    },
-  ) {
+  constructor(dependencies: SNSSQSConsumerDependencies, options: TestConsumerOptions) {
     super(
       dependencies,
       {
-        handlers: [
-          {
-            schema: PERMISSIONS_ADD_MESSAGE_SCHEMA,
-            handler: () => Promise.resolve({ result: 'success' }),
-          },
-        ],
+        handlers: new MessageHandlerConfigBuilder<PERMISSIONS_ADD_MESSAGE_TYPE, undefined>()
+          .addConfig(PERMISSIONS_ADD_MESSAGE_SCHEMA, () => Promise.resolve({ result: 'success' }))
+          .build(),
         messageTypeResolver: { messageTypePath: 'messageType' },
         subscriptionConfig: { updateAttributesIfExists: false },
         ...options,

packages/sqs/lib/utils/sqsInitter.ts

@@ -108,7 +108,7 @@ export async function initSqs(
       const checkResult = await getQueueAttributes(sqsClient, queueUrl, ['QueueArn'])
 
       if (checkResult.error === 'not_found') {
-        throw new Error(`Queue with queueUrl ${locatorConfig.queueUrl} does not exist.`)
+        throw new Error(`Queue with queueUrl ${queueUrl} does not exist.`)
       }
 
       queueArn = checkResult.result?.attributes?.QueueArn

packages/sqs/test/consumers/SqsPermissionConsumer.resourceAvailability.spec.ts

@@ -1,11 +1,16 @@
 import { setTimeout } from 'node:timers/promises'
 import type { SQSClient } from '@aws-sdk/client-sqs'
-import { ResourceAvailabilityTimeoutError } from '@message-queue-toolkit/core'
+import {
+  MessageHandlerConfigBuilder,
+  ResourceAvailabilityTimeoutError,
+} from '@message-queue-toolkit/core'
 import type { AwilixContainer } from 'awilix'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import type { SQSConsumerDependencies } from '../../lib/sqs/AbstractSqsConsumer.ts'
-import { AbstractSqsConsumer } from '../../lib/sqs/AbstractSqsConsumer.ts'
+import {
+  AbstractSqsConsumer,
+  type SQSConsumerDependencies,
+  type SQSConsumerOptions,
+} from '../../lib/sqs/AbstractSqsConsumer.ts'
 import { assertQueue, deleteQueue } from '../../lib/utils/sqsUtils.ts'
 import type { Dependencies } from '../utils/testContext.ts'
 import { registerDependencies } from '../utils/testContext.ts'
@@ -14,38 +19,24 @@ import {
   type PERMISSIONS_ADD_MESSAGE_TYPE,
 } from './userConsumerSchemas.ts'
 
+type TestConsumerOptions = Pick<
+  SQSConsumerOptions<PERMISSIONS_ADD_MESSAGE_TYPE, undefined, undefined>,
+  'locatorConfig' | 'creationConfig' | 'resourceAvailabilityConfig'
+>
+
 // Simple consumer for testing resource availability
 class TestResourceAvailabilityConsumer extends AbstractSqsConsumer<
   PERMISSIONS_ADD_MESSAGE_TYPE,
   undefined,
   undefined
 > {
-  constructor(
-    dependencies: SQSConsumerDependencies,
-    options: {
-      locatorConfig?: {
-        queueUrl?: string
-        queueName?: string
-      }
-      creationConfig?: {
-        queue?: { QueueName: string }
-      }
-      resourceAvailabilityConfig?: {
-        enabled: boolean
-        timeoutMs?: number
-        pollingIntervalMs?: number
-      }
-    },
-  ) {
+  constructor(dependencies: SQSConsumerDependencies, options: TestConsumerOptions) {
     super(
       dependencies,
       {
-        handlers: [
-          {
-            schema: PERMISSIONS_ADD_MESSAGE_SCHEMA,
-            handler: () => Promise.resolve({ result: 'success' }),
-          },
-        ],
+        handlers: new MessageHandlerConfigBuilder<PERMISSIONS_ADD_MESSAGE_TYPE, undefined>()
+          .addConfig(PERMISSIONS_ADD_MESSAGE_SCHEMA, () => Promise.resolve({ result: 'success' }))
+          .build(),
         messageTypeResolver: { messageTypePath: 'messageType' },
         ...options,
       },