@message-queue-toolkit/core 24.2.0 → 25.1.0

package/dist/types/queueOptionsTypes.d.ts

@@ -4,6 +4,7 @@ import type { MessageDeduplicationConfig } from '../message-deduplication/messag
 import type { PayloadStoreConfig } from '../payload-store/payloadStoreTypes.ts';
 import type { MessageHandlerConfig } from '../queues/HandlerContainer.ts';
 import type { HandlerSpy, HandlerSpyParams } from '../queues/HandlerSpy.ts';
+import type { MessageTypeResolverConfig } from '../queues/MessageTypeResolver.ts';
 import type { MessageProcessingResult, TransactionObservabilityManager } from './MessageQueueTypes.ts';
 export type QueueDependencies = {
     errorReporter: ErrorReporter;
@@ -16,9 +17,10 @@ export type ProcessedMessageMetadata<MessagePayloadSchemas extends object = obje
      */
     messageId: string;
     /**
-     * Message type accessed by `messageTypeField`
+     * Message type resolved by `messageTypeResolver`.
+     * May be undefined if messageTypeResolver is not configured.
      */
-    messageType: string;
+    messageType?: string;
     /**
      * Processing result status
      */
@@ -60,8 +62,38 @@ export type QueueConsumerDependencies = {
     consumerErrorResolver: ErrorResolver;
     transactionObservabilityManager: TransactionObservabilityManager;
 };
+/**
+ * Common queue options for publishers and consumers.
+ *
+ * Message type resolution is configured via `messageTypeResolver`.
+ * At least one must be provided for routing to work (unless using a single handler).
+ */
 export type CommonQueueOptions = {
-    messageTypeField: string;
+    /**
+     * Configuration for resolving message types.
+     *
+     * Supports three modes:
+     * - `{ messageTypePath: string }` - field name at the root of the message
+     * - `{ literal: string }` - constant type for all messages
+     * - `{ resolver: fn }` - custom function for complex scenarios (e.g., extracting from attributes)
+     *
+     * @example
+     * // Field path - extracts type from message.type
+     * { messageTypeResolver: { messageTypePath: 'type' } }
+     *
+     * @example
+     * // Constant type - all messages treated as same type
+     * { messageTypeResolver: { literal: 'order.created' } }
+     *
+     * @example
+     * // Custom resolver for Cloud Storage notifications via PubSub
+     * {
+     *   messageTypeResolver: {
+     *     resolver: ({ messageAttributes }) => messageAttributes?.eventType as string
+     *   }
+     * }
+     */
+    messageTypeResolver?: MessageTypeResolverConfig;
     messageIdField?: string;
     messageTimestampField?: string;
     messageDeduplicationIdField?: string;
@@ -80,6 +112,119 @@ export type DeletionConfig = {
     waitForConfirmation?: boolean;
     forceDeleteInProduction?: boolean;
 };
+/**
+ * Symbol to indicate no timeout - polling will continue indefinitely.
+ * Use this for dev/staging environments where you want to wait indefinitely for resources.
+ *
+ * @example
+ * {
+ *   locatorConfig: {
+ *     queueUrl: '...',
+ *     startupResourcePolling: {
+ *       enabled: true,
+ *       timeoutMs: NO_TIMEOUT,
+ *     }
+ *   }
+ * }
+ */
+export declare const NO_TIMEOUT: unique symbol;
+/**
+ * Configuration for startup resource polling mode when resources may not exist at startup.
+ *
+ * This is useful in scenarios where services have cross-dependencies:
+ * - Service A needs to subscribe to Service B's topic
+ * - Service B needs to subscribe to Service A's topic
+ * - Neither can deploy first without the other's topic existing
+ *
+ * When `startupResourcePolling` is provided with `enabled: true` inside `locatorConfig`,
+ * the consumer will poll for the topic/queue to become available instead of failing immediately.
+ *
+ * @example
+ * // Enable with 5 minute timeout
+ * {
+ *   locatorConfig: {
+ *     queueUrl: '...',
+ *     startupResourcePolling: {
+ *       enabled: true,
+ *       timeoutMs: 5 * 60 * 1000,
+ *     }
+ *   }
+ * }
+ *
+ * @example
+ * // Poll indefinitely (useful for dev/staging environments)
+ * {
+ *   locatorConfig: {
+ *     queueUrl: '...',
+ *     startupResourcePolling: {
+ *       enabled: true,
+ *       timeoutMs: NO_TIMEOUT,
+ *     }
+ *   }
+ * }
+ *
+ * @example
+ * // Custom timeout and interval
+ * {
+ *   locatorConfig: {
+ *     queueUrl: '...',
+ *     startupResourcePolling: {
+ *       enabled: true,
+ *       timeoutMs: 10 * 60 * 1000, // 10 minutes
+ *       pollingIntervalMs: 10000,
+ *     }
+ *   }
+ * }
+ */
+export type StartupResourcePollingConfig = {
+    /**
+     * Controls whether polling is enabled.
+     * Must be set to true to enable polling.
+     */
+    enabled?: boolean;
+    /**
+     * Maximum time in milliseconds to wait for the resource to become available.
+     * Use `NO_TIMEOUT` to disable timeout and poll indefinitely.
+     */
+    timeoutMs: number | typeof NO_TIMEOUT;
+    /**
+     * Interval in milliseconds between polling attempts.
+     * Default: 5000 (5 seconds)
+     */
+    pollingIntervalMs?: number;
+    /**
+     * Whether to throw an error when timeout is reached.
+     * - `true` (default): Throws `StartupResourcePollingTimeoutError` when timeout is reached
+     * - `false`: Reports the error via errorReporter, resets the timeout counter, and continues polling
+     *
+     * Use `false` when you want to be notified about prolonged unavailability but don't want to fail.
+     * Default: true
+     */
+    throwOnTimeout?: boolean;
+    /**
+     * Whether to run polling in non-blocking mode.
+     * - `false` (default): init() waits for the resource to become available before resolving
+     * - `true`: If resource is not immediately available, init() resolves immediately and
+     *   polling continues in the background. When the resource becomes available,
+     *   the `onResourceAvailable` callback is invoked.
+     *
+     * Use `true` when you want the service to start quickly without waiting for dependencies.
+     * Default: false
+     */
+    nonBlocking?: boolean;
+};
+/**
+ * Base type for queue locator configurations that includes startup resource polling.
+ * Protocol-specific locator types should extend this.
+ */
+export type BaseQueueLocatorType = {
+    /**
+     * Configuration for startup resource polling mode.
+     * When enabled, the consumer will poll for the resource to become available
+     * instead of failing immediately.
+     */
+    startupResourcePolling?: StartupResourcePollingConfig;
+};
 type NewQueueOptions<CreationConfigType extends CommonCreationConfigType> = {
     creationConfig?: CreationConfigType;
 };

package/dist/types/queueOptionsTypes.js

@@ -1,2 +1,17 @@
-export {};
+/**
+ * Symbol to indicate no timeout - polling will continue indefinitely.
+ * Use this for dev/staging environments where you want to wait indefinitely for resources.
+ *
+ * @example
+ * {
+ *   locatorConfig: {
+ *     queueUrl: '...',
+ *     startupResourcePolling: {
+ *       enabled: true,
+ *       timeoutMs: NO_TIMEOUT,
+ *     }
+ *   }
+ * }
+ */
+export const NO_TIMEOUT = Symbol('NO_TIMEOUT');
 //# sourceMappingURL=queueOptionsTypes.js.map

package/dist/types/queueOptionsTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"queueOptionsTypes.js","sourceRoot":"","sources":["../../lib/types/queueOptionsTypes.ts"],"names":[],"mappings":""}
+{"version":3,"file":"queueOptionsTypes.js","sourceRoot":"","sources":["../../lib/types/queueOptionsTypes.ts"],"names":[],"mappings":"AAoIA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,CAAA"}

package/dist/utils/startupResourcePollingUtils.d.ts

@@ -0,0 +1,59 @@
+import type { CommonLogger, ErrorReporter } from '@lokalise/node-core';
+import { type StartupResourcePollingConfig } from '../types/queueOptionsTypes.ts';
+export type StartupResourcePollingCheckResult<T> = {
+    isAvailable: true;
+    result: T;
+} | {
+    isAvailable: false;
+};
+export type WaitForResourceOptions<T> = {
+    /**
+     * Startup resource polling configuration
+     */
+    config: StartupResourcePollingConfig;
+    /**
+     * Function that checks if the resource is available.
+     * Should return { isAvailable: true, result: T } when resource exists,
+     * or { isAvailable: false } when resource doesn't exist.
+     * Should throw on unexpected errors.
+     */
+    checkFn: () => Promise<StartupResourcePollingCheckResult<T>>;
+    /**
+     * Human-readable name of the resource for logging
+     */
+    resourceName: string;
+    /**
+     * Logger instance for progress logging
+     */
+    logger?: CommonLogger;
+    /**
+     * Error reporter for reporting timeout errors when throwOnTimeout is false.
+     * Required when config.throwOnTimeout is false.
+     */
+    errorReporter?: ErrorReporter;
+    /**
+     * Callback invoked when resource becomes available in non-blocking mode.
+     * Only used when config.nonBlocking is true and the resource was not immediately available.
+     */
+    onResourceAvailable?: (result: T) => void;
+};
+export declare class StartupResourcePollingTimeoutError extends Error {
+    readonly resourceName: string;
+    readonly timeoutMs: number;
+    constructor(resourceName: string, timeoutMs: number);
+}
+/**
+ * Waits for a resource to become available by polling.
+ * This is used for startup resource polling mode where resources may not exist at startup.
+ *
+ * @param options - Configuration and check function
+ * @returns The result from the check function when resource becomes available,
+ *          or undefined if nonBlocking is true and resource was not immediately available
+ * @throws StartupResourcePollingTimeoutError if timeout is reached and throwOnTimeout is true (default)
+ */
+export declare function waitForResource<T>(options: WaitForResourceOptions<T>): Promise<T | undefined>;
+/**
+ * Helper to check if startup resource polling is enabled.
+ * Returns true only when config is provided and enabled is explicitly true.
+ */
+export declare function isStartupResourcePollingEnabled(config?: StartupResourcePollingConfig): config is StartupResourcePollingConfig;

package/dist/utils/startupResourcePollingUtils.js

@@ -0,0 +1,199 @@
+import { setTimeout } from 'node:timers/promises';
+import { NO_TIMEOUT } from "../types/queueOptionsTypes.js";
+const DEFAULT_POLLING_INTERVAL_MS = 5000;
+export class StartupResourcePollingTimeoutError extends Error {
+    resourceName;
+    timeoutMs;
+    constructor(resourceName, timeoutMs) {
+        super(`Timeout waiting for resource "${resourceName}" to become available after ${timeoutMs}ms. ` +
+            'The resource may not exist or there may be a configuration issue.');
+        this.name = 'StartupResourcePollingTimeoutError';
+        this.resourceName = resourceName;
+        this.timeoutMs = timeoutMs;
+    }
+}
+function checkTimeoutExceeded(hasTimeout, timeoutMs, startTime, resourceName, attemptCount, logger) {
+    if (!hasTimeout)
+        return { exceeded: false };
+    const elapsedMs = Date.now() - startTime;
+    if (elapsedMs >= timeoutMs) {
+        logger?.error({
+            message: `Timeout waiting for resource "${resourceName}" to become available`,
+            resourceName,
+            timeoutMs,
+            attemptCount,
+            elapsedMs,
+        });
+        return {
+            exceeded: true,
+            error: new StartupResourcePollingTimeoutError(resourceName, timeoutMs),
+        };
+    }
+    return { exceeded: false };
+}
+/**
+ * Handles timeout condition - either throws or reports and returns new timeout count.
+ * @returns Updated timeout count after handling
+ */
+function handleTimeout(params) {
+    const { timeoutResult, throwOnTimeout, resourceName, timeoutMs, attemptCount, timeoutCount, logger, errorReporter, } = params;
+    if (throwOnTimeout) {
+        throw timeoutResult.error;
+    }
+    // Report error and reset timeout counter
+    const newTimeoutCount = timeoutCount + 1;
+    errorReporter?.report({
+        error: timeoutResult.error,
+        context: {
+            resourceName,
+            timeoutMs,
+            attemptCount,
+            timeoutCount: newTimeoutCount,
+        },
+    });
+    logger?.warn({
+        message: `Timeout waiting for resource "${resourceName}", resetting timeout counter and continuing`,
+        resourceName,
+        timeoutMs,
+        attemptCount,
+        timeoutCount: newTimeoutCount,
+    });
+    return newTimeoutCount;
+}
+function logResourceAvailable(resourceName, attemptCount, startTime, logger) {
+    const elapsedMs = Date.now() - startTime;
+    logger?.info({
+        message: `Resource "${resourceName}" is now available`,
+        resourceName,
+        attemptCount,
+        elapsedMs,
+    });
+}
+/**
+ * Internal polling loop that waits for a resource to become available.
+ * Separated from main function to support non-blocking mode.
+ */
+async function pollForResource(options, pollingIntervalMs, hasTimeout, timeoutMs, throwOnTimeout, initialAttemptCount) {
+    const { checkFn, resourceName, logger, errorReporter } = options;
+    let startTime = Date.now();
+    let attemptCount = initialAttemptCount;
+    let timeoutCount = 0;
+    while (true) {
+        attemptCount++;
+        const timeoutResult = checkTimeoutExceeded(hasTimeout, timeoutMs, startTime, resourceName, attemptCount, logger);
+        if (timeoutResult.exceeded) {
+            timeoutCount = handleTimeout({
+                timeoutResult,
+                throwOnTimeout,
+                resourceName,
+                timeoutMs,
+                attemptCount,
+                timeoutCount,
+                logger,
+                errorReporter,
+            });
+            startTime = Date.now();
+        }
+        const result = await checkFn().catch((error) => {
+            // Unexpected error during check - log and rethrow
+            logger?.error({
+                message: `Error checking resource availability for "${resourceName}"`,
+                resourceName,
+                error,
+                attemptCount,
+            });
+            throw error;
+        });
+        if (result.isAvailable) {
+            logResourceAvailable(resourceName, attemptCount, startTime, logger);
+            return result.result;
+        }
+        // Resource not available yet, log and wait
+        if (attemptCount === 1 || attemptCount % 12 === 0) {
+            // Log on first attempt and then every minute (assuming 5s interval)
+            const elapsedMs = Date.now() - startTime;
+            logger?.debug({
+                message: `Resource "${resourceName}" not available yet, will retry`,
+                resourceName,
+                attemptCount,
+                elapsedMs,
+                nextRetryInMs: pollingIntervalMs,
+            });
+        }
+        // Wait before next attempt
+        await setTimeout(pollingIntervalMs);
+    }
+}
+/**
+ * Waits for a resource to become available by polling.
+ * This is used for startup resource polling mode where resources may not exist at startup.
+ *
+ * @param options - Configuration and check function
+ * @returns The result from the check function when resource becomes available,
+ *          or undefined if nonBlocking is true and resource was not immediately available
+ * @throws StartupResourcePollingTimeoutError if timeout is reached and throwOnTimeout is true (default)
+ */
+export async function waitForResource(options) {
+    const { config, checkFn, resourceName, logger, onResourceAvailable } = options;
+    const pollingIntervalMs = config.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS;
+    const hasTimeout = config.timeoutMs !== NO_TIMEOUT;
+    const timeoutMs = hasTimeout ? config.timeoutMs : 0;
+    const throwOnTimeout = config.throwOnTimeout !== false;
+    const nonBlocking = config.nonBlocking === true;
+    logger?.info({
+        message: `Waiting for resource "${resourceName}" to become available`,
+        resourceName,
+        pollingIntervalMs,
+        timeoutMs: hasTimeout ? timeoutMs : 'NO_TIMEOUT',
+        throwOnTimeout,
+        nonBlocking,
+    });
+    // First check - always done synchronously
+    const initialResult = await checkFn().catch((error) => {
+        logger?.error({
+            message: `Error checking resource availability for "${resourceName}"`,
+            resourceName,
+            error,
+            attemptCount: 1,
+        });
+        throw error;
+    });
+    if (initialResult.isAvailable) {
+        logResourceAvailable(resourceName, 1, Date.now(), logger);
+        return initialResult.result;
+    }
+    // Resource not available on first check
+    if (nonBlocking) {
+        // Start background polling and return immediately
+        logger?.info({
+            message: `Resource "${resourceName}" not immediately available, starting background polling`,
+            resourceName,
+            pollingIntervalMs,
+        });
+        // Fire and forget - start polling in background
+        setTimeout(pollingIntervalMs).then(() => {
+            pollForResource(options, pollingIntervalMs, hasTimeout, timeoutMs, throwOnTimeout, 1)
+                .then((result) => {
+                onResourceAvailable?.(result);
+            })
+                .catch((error) => {
+                logger?.error({
+                    message: `Background polling for resource "${resourceName}" failed`,
+                    resourceName,
+                    error,
+                });
+            });
+        });
+        return undefined;
+    }
+    // Blocking mode - continue polling and wait for result
+    return pollForResource(options, pollingIntervalMs, hasTimeout, timeoutMs, throwOnTimeout, 1);
+}
+/**
+ * Helper to check if startup resource polling is enabled.
+ * Returns true only when config is provided and enabled is explicitly true.
+ */
+export function isStartupResourcePollingEnabled(config) {
+    return config?.enabled === true;
+}
+//# sourceMappingURL=startupResourcePollingUtils.js.map

package/dist/utils/startupResourcePollingUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startupResourcePollingUtils.js","sourceRoot":"","sources":["../../lib/utils/startupResourcePollingUtils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@message-queue-toolkit/core",
-    "version": "24.2.0",
+    "version": "25.1.0",
     "license": "MIT",
     "description": "Useful utilities, interfaces and base classes for message queue handling. Supports AMQP and SQS with a common abstraction on top currently",
     "maintainers": [
@@ -28,7 +28,8 @@
         "@lokalise/node-core": "^14.2.0",
         "@lokalise/universal-ts-utils": "^4.5.1",
         "@message-queue-toolkit/schemas": "^7.0.0",
-        "fast-equals": "^5.2.2",
+        "dot-prop": "^10.1.0",
+        "fast-equals": "^6.0.0",
         "json-stream-stringify": "^3.1.6",
         "tmp": "^0.2.3",
         "toad-cache": "^3.7.0"
@@ -40,7 +41,7 @@
         "@biomejs/biome": "^2.3.8",
         "@lokalise/biome-config": "^3.1.0",
         "@lokalise/tsconfig": "^3.0.0",
-        "@types/node": "^24.10.1",
+        "@types/node": "^25.0.2",
         "@types/tmp": "^0.2.6",
         "@vitest/coverage-v8": "^3.2.4",
         "awilix": "^12.0.5",
@@ -48,7 +49,7 @@
         "rimraf": "^6.0.1",
         "typescript": "^5.9.2",
         "vitest": "^3.2.4",
-        "zod": "^4.0.17"
+        "zod": "^4.1.13"
     },
     "homepage": "https://github.com/kibertoad/message-queue-toolkit",
     "repository": {