@fluojs/queue 1.0.2 → 3.0.0

package/dist/worker-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-discovery.d.ts","sourceRoot":"","sources":["../src/worker-discovery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGzE,OAAO,EAA8B,KAAK,qBAAqB,EAAkD,MAAM,cAAc,CAAC;AACtI,OAAO,KAAK,EAAE,4BAA4B,EAAE,YAAY,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAEzH;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,OAAO,EAAE,4BAA4B,EACrC,MAAM,EAAE,iBAAiB,EACzB,YAAY,CAAC,EAAE,qBAAqB,GACnC,GAAG,CAAC,YAAY,EAAE,qBAAqB,CAAC,CA4C1C"}
+{"version":3,"file":"worker-discovery.d.ts","sourceRoot":"","sources":["../src/worker-discovery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAA8B,KAAK,qBAAqB,EAAkD,MAAM,cAAc,CAAC;AAEtI,OAAO,KAAK,EAAE,4BAA4B,EAAE,YAAY,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAEzH;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,OAAO,EAAE,4BAA4B,EACrC,MAAM,EAAE,iBAAiB,GAAG,SAAS,EACrC,YAAY,CAAC,EAAE,qBAAqB,GACnC,GAAG,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAoC1C"}

package/dist/worker-discovery.js

@@ -1,11 +1,12 @@
-import { getQueueWorkerMetadata } from './metadata.js';
 import { collectDiscoveryCandidates, normalizePositiveInteger, normalizeRateLimiter } from './helpers.js';
+import { getQueueWorkerMetadata } from './metadata.js';
 /**
  * Discover queue worker descriptors.
  *
  * @param compiledModules The compiled modules.
  * @param options The options.
- * @param logger The logger.
+ * @param logger Optional logger for skipped worker registrations.
+ * @param moduleFilter Optional compiled-module ownership filter.
  * @returns The discover queue worker descriptors result.
  */
 export function discoverQueueWorkerDescriptors(compiledModules, options, logger, moduleFilter) {
@@ -17,18 +18,16 @@ export function discoverQueueWorkerDescriptors(compiledModules, options, logger,
       continue;
     }
     if (candidate.scope !== 'singleton') {
-      logger.warn(`${candidate.targetType.name} in module ${candidate.moduleName} declares @QueueWorker() but is registered with ${candidate.scope} scope. Queue workers are registered only for singleton providers.`, 'QueueLifecycleService');
+      logger?.warn(`${candidate.targetType.name} in module ${candidate.moduleName} declares @QueueWorker() but is registered with ${candidate.scope} scope. Queue workers are registered only for singleton providers.`, 'QueueLifecycleService');
       continue;
     }
     const jobType = metadata.jobType;
     if (descriptorsByJobType.has(jobType)) {
-      logger.warn(`Duplicate @QueueWorker() registration for job type ${jobType.name} was ignored in ${candidate.moduleName}.`, 'QueueLifecycleService');
-      continue;
+      throw new Error(`Duplicate @QueueWorker() registration for job type ${jobType.name}.`);
     }
     const jobName = metadata.options.jobName ?? jobType.name;
     if (seenJobNames.has(jobName)) {
-      logger.warn(`Duplicate queue job name ${jobName} was ignored in ${candidate.moduleName}.`, 'QueueLifecycleService');
-      continue;
+      throw new Error(`Duplicate queue job name ${jobName}.`);
     }
     seenJobNames.add(jobName);
     descriptorsByJobType.set(jobType, createWorkerDescriptor(candidate.moduleName, candidate.token, candidate.targetType.name, metadata, jobName, options));

package/dist/worker-ownership.d.ts

@@ -0,0 +1,10 @@
+import type { ApplicationLogger, CompiledModule, ModuleType } from '@fluojs/runtime';
+/**
+ * Validates queue registrations that would assign one BullMQ queue to workers in different DI scopes.
+ *
+ * @param compiledModules Complete compiled application module graph.
+ * @param logger Application logger used for compatibility diagnostics.
+ * @param validationModuleType Queue registration module that triggers this one-time application-wide validation.
+ */
+export declare function assertUniqueQueueWorkerOwnership(compiledModules: readonly CompiledModule[], logger: ApplicationLogger, validationModuleType: ModuleType): void;
+//# sourceMappingURL=worker-ownership.d.ts.map

package/dist/worker-ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-ownership.d.ts","sourceRoot":"","sources":["../src/worker-ownership.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA+HrF;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,MAAM,EAAE,iBAAiB,EACzB,oBAAoB,EAAE,UAAU,GAC/B,IAAI,CAmEN"}

package/dist/worker-ownership.js

@@ -0,0 +1,102 @@
+import { QUEUE_MODULE_CONTEXT_MARKER } from './tokens.js';
+import { discoverQueueWorkerDescriptors } from './worker-discovery.js';
+const UNCONFIGURED_BACKEND_IDENTITY = '(unconfigured)';
+function isQueueModuleContext(value) {
+  return typeof value === 'object' && value !== null && QUEUE_MODULE_CONTEXT_MARKER in value && value[QUEUE_MODULE_CONTEXT_MARKER] === true && 'moduleType' in value && typeof value.moduleType === 'function' && 'options' in value && typeof value.options === 'object' && value.options !== null && 'registrationTokens' in value && Array.isArray(value.registrationTokens) && 'scope' in value && typeof value.scope === 'string';
+}
+function collectQueueModuleContexts(compiledModules) {
+  const contexts = [];
+  for (const compiledModule of compiledModules) {
+    for (const provider of compiledModule.definition.providers ?? []) {
+      if (typeof provider !== 'object' || provider === null || !('useValue' in provider)) {
+        continue;
+      }
+      if (isQueueModuleContext(provider.useValue)) {
+        contexts.push(provider.useValue);
+      }
+    }
+  }
+  return contexts;
+}
+function canReachQueueRegistration(compiledModule, moduleContext, compiledModulesByType, visited = new Set()) {
+  if (visited.has(compiledModule.type)) {
+    return false;
+  }
+  visited.add(compiledModule.type);
+  for (const importedModuleType of compiledModule.definition.imports ?? []) {
+    if (importedModuleType === moduleContext.moduleType) {
+      return true;
+    }
+    const importedModule = compiledModulesByType.get(importedModuleType);
+    if (!importedModule || !moduleContext.registrationTokens.some(token => importedModule.exportedTokens.has(token))) {
+      continue;
+    }
+    if (canReachQueueRegistration(importedModule, moduleContext, compiledModulesByType, visited)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createQueueDiscoveryModuleFilter(compiledModules, moduleContext) {
+  if (moduleContext.options.global) {
+    return () => true;
+  }
+  const compiledModulesByType = new Map(compiledModules.map(compiledModule => [compiledModule.type, compiledModule]));
+  return compiledModule => canReachQueueRegistration(compiledModule, moduleContext, compiledModulesByType);
+}
+function assertUniqueQueueScopes(moduleContexts) {
+  const seenScopes = new Set();
+  for (const moduleContext of moduleContexts) {
+    if (seenScopes.has(moduleContext.scope)) {
+      throw new Error(`Duplicate @fluojs/queue scope "${moduleContext.scope}" registered. Provide a unique QueueModule.forRoot({ scope }) value for each scoped queue registration.`);
+    }
+    seenScopes.add(moduleContext.scope);
+  }
+}
+function canShareBackend(ownershipNamespace, existingOwner) {
+  return ownershipNamespace === undefined || existingOwner.ownershipNamespace === undefined || ownershipNamespace === existingOwner.ownershipNamespace;
+}
+
+/**
+ * Validates queue registrations that would assign one BullMQ queue to workers in different DI scopes.
+ *
+ * @param compiledModules Complete compiled application module graph.
+ * @param logger Application logger used for compatibility diagnostics.
+ * @param validationModuleType Queue registration module that triggers this one-time application-wide validation.
+ */
+export function assertUniqueQueueWorkerOwnership(compiledModules, logger, validationModuleType) {
+  const moduleContexts = collectQueueModuleContexts(compiledModules);
+  assertUniqueQueueScopes(moduleContexts);
+  if (moduleContexts[0]?.moduleType !== validationModuleType) {
+    return;
+  }
+  const ownersByJobName = new Map();
+  for (const moduleContext of moduleContexts) {
+    const ownershipNamespace = moduleContext.options.ownershipNamespace;
+    if (ownershipNamespace === undefined) {
+      logger.warn(`Queue ownership namespace is unconfigured for scope "${moduleContext.scope}". Set QueueModule.forRoot({ ownershipNamespace }) to a stable identity shared only by registrations that use the same BullMQ backend.`, 'QueueLifecycleService');
+    }
+    const descriptors = discoverQueueWorkerDescriptors(compiledModules, moduleContext.options, undefined, createQueueDiscoveryModuleFilter(compiledModules, moduleContext));
+    for (const descriptor of descriptors.values()) {
+      const owners = ownersByJobName.get(descriptor.jobName) ?? [];
+      const compatibleOwners = owners.filter(owner => canShareBackend(ownershipNamespace, owner));
+      const existingOwner = compatibleOwners.find(owner => owner.ownershipEnforcement === 'reject') ?? compatibleOwners[0];
+      if (existingOwner) {
+        const backendIdentity = ownershipNamespace === undefined || existingOwner.ownershipNamespace === undefined ? UNCONFIGURED_BACKEND_IDENTITY : ownershipNamespace;
+        const message = `Cross-scope @fluojs/queue worker ownership collision for backend identity "${backendIdentity}" and jobName "${descriptor.jobName}" between scopes "${existingOwner.scope}" (${existingOwner.workerName} in ${existingOwner.moduleName}) and "${moduleContext.scope}" (${descriptor.workerName} in ${descriptor.moduleName}).`;
+        if (existingOwner.ownershipEnforcement === 'reject' || moduleContext.options.ownershipEnforcement === 'reject') {
+          throw new Error(`${message} Configure distinct ownershipNamespace or @QueueWorker(..., { jobName }) values.`);
+        }
+        logger.warn(`${message} Set matching QueueModule.forRoot({ ownershipNamespace }) values for registrations that share one BullMQ backend, then opt into ownershipEnforcement: "reject" to fail before BullMQ resources are created.`, 'QueueLifecycleService');
+      }
+      owners.push({
+        moduleName: descriptor.moduleName,
+        ownershipEnforcement: moduleContext.options.ownershipEnforcement,
+        ownershipNamespace,
+        scope: moduleContext.scope,
+        workerName: descriptor.workerName
+      });
+      ownersByJobName.set(descriptor.jobName, owners);
+    }
+  }
+}

package/package.json

@@ -10,7 +10,7 @@
     "redis",
     "dlq"
   ],
-  "version": "1.0.2",
+  "version": "3.0.0",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -19,7 +19,7 @@
     "directory": "packages/queue"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0 <27"
   },
   "publishConfig": {
     "access": "public"
@@ -37,14 +37,14 @@
     "dist"
   ],
   "dependencies": {
-    "bullmq": "^5.58.0",
-    "@fluojs/core": "^1.0.3",
-    "@fluojs/di": "^1.1.0",
-    "@fluojs/redis": "^1.0.2",
-    "@fluojs/runtime": "^1.1.8"
+    "bullmq": "^5.81.1",
+    "@fluojs/core": "^2.0.0",
+    "@fluojs/di": "^3.0.0",
+    "@fluojs/redis": "^2.0.0",
+    "@fluojs/runtime": "^3.0.0"
   },
   "devDependencies": {
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "prebuild": "node ../../tooling/scripts/clean-dist.mjs",