atomic-queues 1.0.13

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,cAAc,UAAU,CAAC;AAGzB,cAAc,UAAU,CAAC;AAGzB,cAAc,YAAY,CAAC;AAG3B,cAAc,cAAc,CAAC;AAG7B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * =============================================================================
+ * ATOMIC QUEUES
+ * =============================================================================
+ *
+ * A plug-and-play NestJS library for atomic process handling per entity
+ * with BullMQ, Redis distributed locking, and dynamic worker management.
+ *
+ * Features:
+ * - Dynamic per-entity queue creation
+ * - Worker lifecycle management with heartbeat TTL
+ * - Distributed resource locking (Redis/Lua scripts)
+ * - Graceful shutdown coordination via pub/sub
+ * - Cron-based worker spawning/cleanup
+ * - CQRS command/query dynamic execution
+ * - Index tracking for jobs, workers, and queues
+ *
+ * @example
+ * ```typescript
+ * import { AtomicQueuesModule, QueueManagerService, WorkerManagerService } from 'atomic-queues';
+ *
+ * @Module({
+ *   imports: [
+ *     AtomicQueuesModule.forRoot({
+ *       redis: { host: 'localhost', port: 6379 },
+ *       enableCronManager: true,
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @packageDocumentation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Domain - Interfaces and Types
+__exportStar(require("./domain"), exports);
+// Module
+__exportStar(require("./module"), exports);
+// Services
+__exportStar(require("./services"), exports);
+// Decorators
+__exportStar(require("./decorators"), exports);
+// Utilities
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;;;;;;;;;;;;;;;;AAEH,gCAAgC;AAChC,2CAAyB;AAEzB,SAAS;AACT,2CAAyB;AAEzB,WAAW;AACX,6CAA2B;AAE3B,aAAa;AACb,+CAA6B;AAE7B,YAAY;AACZ,0CAAwB"}

package/dist/module/atomic-queues.module.d.ts

@@ -0,0 +1,97 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { IAtomicQueuesModuleConfig } from '../domain';
+/**
+ * Async module options for AtomicQueuesModule.forRootAsync()
+ */
+export interface AtomicQueuesModuleAsyncOptions {
+    /**
+     * Imports to include in the module
+     */
+    imports?: Type<unknown>[];
+    /**
+     * Factory function to create the module configuration
+     */
+    useFactory: (...args: unknown[]) => Promise<IAtomicQueuesModuleConfig> | IAtomicQueuesModuleConfig;
+    /**
+     * Dependencies to inject into the factory
+     */
+    inject?: unknown[];
+    /**
+     * Whether to make the module global
+     */
+    isGlobal?: boolean;
+}
+/**
+ * AtomicQueuesModule
+ *
+ * Main module for the AtomicQueues library.
+ * Provides all services for atomic process handling per entity.
+ *
+ * @example
+ * ```typescript
+ * // Synchronous configuration
+ * @Module({
+ *   imports: [
+ *     AtomicQueuesModule.forRoot({
+ *       redis: {
+ *         host: 'localhost',
+ *         port: 6379,
+ *       },
+ *       enableCronManager: true,
+ *       cronInterval: 5000,
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * // Async configuration
+ * @Module({
+ *   imports: [
+ *     AtomicQueuesModule.forRootAsync({
+ *       imports: [ConfigModule],
+ *       useFactory: (configService: ConfigService) => ({
+ *         redis: {
+ *           url: configService.get('REDIS_URL'),
+ *         },
+ *         enableCronManager: true,
+ *       }),
+ *       inject: [ConfigService],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare class AtomicQueuesModule {
+    /**
+     * Configure the module with synchronous options.
+     */
+    static forRoot(config: IAtomicQueuesModuleConfig): DynamicModule;
+    /**
+     * Configure the module with asynchronous options.
+     */
+    static forRootAsync(options: AtomicQueuesModuleAsyncOptions): DynamicModule;
+    /**
+     * Create a feature module for entity-specific configuration.
+     * Use this for registering entity scaling configurations.
+     */
+    static forFeature(options: {
+        entityType: string;
+        getDesiredWorkerCount: (entityId: string) => Promise<number>;
+        getActiveEntityIds: () => Promise<string[]>;
+        maxWorkersPerEntity?: number;
+    }): DynamicModule;
+    /**
+     * Create synchronous Redis provider.
+     */
+    private static createRedisProvider;
+    /**
+     * Create async configuration provider.
+     */
+    private static createAsyncConfigProvider;
+    /**
+     * Create async Redis provider.
+     */
+    private static createAsyncRedisProvider;
+}
+//# sourceMappingURL=atomic-queues.module.d.ts.map

package/dist/module/atomic-queues.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-queues.module.d.ts","sourceRoot":"","sources":["../../src/module/atomic-queues.module.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAIb,IAAI,EACL,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAe,MAAM,WAAW,CAAC;AAiBnE;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;OAEG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAE1B;;OAEG;IACH,UAAU,EAAE,CACV,GAAG,IAAI,EAAE,OAAO,EAAE,KACf,OAAO,CAAC,yBAAyB,CAAC,GAAG,yBAAyB,CAAC;IAEpE;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAEa,kBAAkB;IAC7B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,yBAAyB,GAAG,aAAa;IAuBhE;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,8BAA8B,GAAG,aAAa;IAmB3E;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE;QACzB,UAAU,EAAE,MAAM,CAAC;QACnB,qBAAqB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;QAC7D,kBAAkB,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5C,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B,GAAG,aAAa;IAgBjB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAuBlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAUxC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;CAqBxC"}

package/dist/module/atomic-queues.module.js

@@ -0,0 +1,197 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var AtomicQueuesModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomicQueuesModule = void 0;
+const common_1 = require("@nestjs/common");
+const ioredis_1 = __importDefault(require("ioredis"));
+const services_1 = require("../services");
+/**
+ * Core services provided by the module
+ */
+const CORE_SERVICES = [
+    services_1.QueueManagerService,
+    services_1.WorkerManagerService,
+    services_1.ResourceLockService,
+    services_1.IndexManagerService,
+    services_1.JobProcessorRegistry,
+    services_1.DynamicExecutorService,
+    services_1.AtomicJobProcessor,
+    services_1.CronManagerService,
+    services_1.ServiceQueueManager,
+    services_1.ShutdownStateService,
+];
+/**
+ * AtomicQueuesModule
+ *
+ * Main module for the AtomicQueues library.
+ * Provides all services for atomic process handling per entity.
+ *
+ * @example
+ * ```typescript
+ * // Synchronous configuration
+ * @Module({
+ *   imports: [
+ *     AtomicQueuesModule.forRoot({
+ *       redis: {
+ *         host: 'localhost',
+ *         port: 6379,
+ *       },
+ *       enableCronManager: true,
+ *       cronInterval: 5000,
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * // Async configuration
+ * @Module({
+ *   imports: [
+ *     AtomicQueuesModule.forRootAsync({
+ *       imports: [ConfigModule],
+ *       useFactory: (configService: ConfigService) => ({
+ *         redis: {
+ *           url: configService.get('REDIS_URL'),
+ *         },
+ *         enableCronManager: true,
+ *       }),
+ *       inject: [ConfigService],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+let AtomicQueuesModule = AtomicQueuesModule_1 = class AtomicQueuesModule {
+    /**
+     * Configure the module with synchronous options.
+     */
+    static forRoot(config) {
+        const redisProvider = this.createRedisProvider(config);
+        return {
+            module: AtomicQueuesModule_1,
+            // Note: CqrsModule should be imported by the consuming app, not here
+            // to avoid duplicate CommandBus/QueryBus instances
+            providers: [
+                {
+                    provide: services_1.ATOMIC_QUEUES_CONFIG,
+                    useValue: config,
+                },
+                redisProvider,
+                ...CORE_SERVICES,
+            ],
+            exports: [
+                services_1.ATOMIC_QUEUES_CONFIG,
+                services_1.ATOMIC_QUEUES_REDIS,
+                ...CORE_SERVICES,
+            ],
+        };
+    }
+    /**
+     * Configure the module with asynchronous options.
+     */
+    static forRootAsync(options) {
+        const configProvider = this.createAsyncConfigProvider(options);
+        const redisProvider = this.createAsyncRedisProvider();
+        return {
+            module: AtomicQueuesModule_1,
+            // Note: CqrsModule should be imported by the consuming app, not here
+            // to avoid duplicate CommandBus/QueryBus instances
+            imports: [...(options.imports || [])],
+            providers: [configProvider, redisProvider, ...CORE_SERVICES],
+            exports: [
+                services_1.ATOMIC_QUEUES_CONFIG,
+                services_1.ATOMIC_QUEUES_REDIS,
+                ...CORE_SERVICES,
+            ],
+            global: options.isGlobal ?? true,
+        };
+    }
+    /**
+     * Create a feature module for entity-specific configuration.
+     * Use this for registering entity scaling configurations.
+     */
+    static forFeature(options) {
+        return {
+            module: AtomicQueuesModule_1,
+            providers: [
+                {
+                    provide: `ENTITY_CONFIG_${options.entityType}`,
+                    useValue: options,
+                },
+            ],
+        };
+    }
+    // =========================================================================
+    // PRIVATE METHODS
+    // =========================================================================
+    /**
+     * Create synchronous Redis provider.
+     */
+    static createRedisProvider(config) {
+        return {
+            provide: services_1.ATOMIC_QUEUES_REDIS,
+            useFactory: () => {
+                if (config.redis.url) {
+                    return new ioredis_1.default(config.redis.url, {
+                        maxRetriesPerRequest: config.redis.maxRetriesPerRequest ?? null,
+                    });
+                }
+                return new ioredis_1.default({
+                    host: config.redis.host || 'localhost',
+                    port: config.redis.port || 6379,
+                    password: config.redis.password,
+                    db: config.redis.db,
+                    maxRetriesPerRequest: config.redis.maxRetriesPerRequest ?? null,
+                });
+            },
+        };
+    }
+    /**
+     * Create async configuration provider.
+     */
+    static createAsyncConfigProvider(options) {
+        return {
+            provide: services_1.ATOMIC_QUEUES_CONFIG,
+            useFactory: options.useFactory,
+            inject: (options.inject || []),
+        };
+    }
+    /**
+     * Create async Redis provider.
+     */
+    static createAsyncRedisProvider() {
+        return {
+            provide: services_1.ATOMIC_QUEUES_REDIS,
+            useFactory: (config) => {
+                if (config.redis.url) {
+                    return new ioredis_1.default(config.redis.url, {
+                        maxRetriesPerRequest: config.redis.maxRetriesPerRequest ?? null,
+                    });
+                }
+                return new ioredis_1.default({
+                    host: config.redis.host || 'localhost',
+                    port: config.redis.port || 6379,
+                    password: config.redis.password,
+                    db: config.redis.db,
+                    maxRetriesPerRequest: config.redis.maxRetriesPerRequest ?? null,
+                });
+            },
+            inject: [services_1.ATOMIC_QUEUES_CONFIG],
+        };
+    }
+};
+exports.AtomicQueuesModule = AtomicQueuesModule;
+exports.AtomicQueuesModule = AtomicQueuesModule = AtomicQueuesModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], AtomicQueuesModule);
+//# sourceMappingURL=atomic-queues.module.js.map

package/dist/module/atomic-queues.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-queues.module.js","sourceRoot":"","sources":["../../src/module/atomic-queues.module.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,2CAMwB;AACxB,sDAA4B;AAE5B,0CAcqB;AA6BrB;;GAEG;AACH,MAAM,aAAa,GAAe;IAChC,8BAAmB;IACnB,+BAAoB;IACpB,8BAAmB;IACnB,8BAAmB;IACnB,+BAAoB;IACpB,iCAAsB;IACtB,6BAAkB;IAClB,6BAAkB;IAClB,8BAAmB;IACnB,+BAAoB;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGI,IAAM,kBAAkB,0BAAxB,MAAM,kBAAkB;IAC7B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAiC;QAC9C,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAEvD,OAAO;YACL,MAAM,EAAE,oBAAkB;YAC1B,qEAAqE;YACrE,mDAAmD;YACnD,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,+BAAoB;oBAC7B,QAAQ,EAAE,MAAM;iBACjB;gBACD,aAAa;gBACb,GAAG,aAAa;aACjB;YACD,OAAO,EAAE;gBACP,+BAAoB;gBACpB,8BAAmB;gBACnB,GAAG,aAAa;aACjB;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAuC;QACzD,MAAM,cAAc,GAAG,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,aAAa,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEtD,OAAO;YACL,MAAM,EAAE,oBAAkB;YAC1B,qEAAqE;YACrE,mDAAmD;YACnD,OAAO,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;YACrC,SAAS,EAAE,CAAC,cAAc,EAAE,aAAa,EAAE,GAAG,aAAa,CAAC;YAC5D,OAAO,EAAE;gBACP,+BAAoB;gBACpB,8BAAmB;gBACnB,GAAG,aAAa;aACjB;YACD,MAAM,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI;SACjC,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,OAKjB;QACC,OAAO;YACL,MAAM,EAAE,oBAAkB;YAC1B,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,iBAAiB,OAAO,CAAC,UAAU,EAAE;oBAC9C,QAAQ,EAAE,OAAO;iBAClB;aACF;SACF,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,kBAAkB;IAClB,4EAA4E;IAE5E;;OAEG;IACK,MAAM,CAAC,mBAAmB,CAChC,MAAiC;QAEjC,OAAO;YACL,OAAO,EAAE,8BAAmB;YAC5B,UAAU,EAAE,GAAG,EAAE;gBACf,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;oBACrB,OAAO,IAAI,iBAAK,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE;wBACjC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,oBAAoB,IAAI,IAAI;qBAChE,CAAC,CAAC;gBACL,CAAC;gBAED,OAAO,IAAI,iBAAK,CAAC;oBACf,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,WAAW;oBACtC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI;oBAC/B,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ;oBAC/B,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE;oBACnB,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,oBAAoB,IAAI,IAAI;iBAChE,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,yBAAyB,CACtC,OAAuC;QAEvC,OAAO;YACL,OAAO,EAAE,+BAAoB;YAC7B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAAU;SACxC,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,wBAAwB;QACrC,OAAO;YACL,OAAO,EAAE,8BAAmB;YAC5B,UAAU,EAAE,CAAC,MAAiC,EAAE,EAAE;gBAChD,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;oBACrB,OAAO,IAAI,iBAAK,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE;wBACjC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,oBAAoB,IAAI,IAAI;qBAChE,CAAC,CAAC;gBACL,CAAC;gBAED,OAAO,IAAI,iBAAK,CAAC;oBACf,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,WAAW;oBACtC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI;oBAC/B,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ;oBAC/B,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE;oBACnB,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,oBAAoB,IAAI,IAAI;iBAChE,CAAC,CAAC;YACL,CAAC;YACD,MAAM,EAAE,CAAC,+BAAoB,CAAC;SAC/B,CAAC;IACJ,CAAC;CACF,CAAA;AAzIY,gDAAkB;6BAAlB,kBAAkB;IAF9B,IAAA,eAAM,GAAE;IACR,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,kBAAkB,CAyI9B"}

package/dist/module/index.d.ts

@@ -0,0 +1,2 @@
+export * from './atomic-queues.module';
+//# sourceMappingURL=index.d.ts.map

package/dist/module/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/module/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/module/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./atomic-queues.module"), exports);
+//# sourceMappingURL=index.js.map

package/dist/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/module/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAuC"}

package/dist/services/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Injection tokens for AtomicQueues module
+ */
+/** Redis client injection token */
+export declare const ATOMIC_QUEUES_REDIS: unique symbol;
+/** Module configuration injection token */
+export declare const ATOMIC_QUEUES_CONFIG: unique symbol;
+/** Async module options injection token */
+export declare const ATOMIC_QUEUES_MODULE_OPTIONS: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

package/dist/services/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/services/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,mCAAmC;AACnC,eAAO,MAAM,mBAAmB,eAAgC,CAAC;AAEjE,2CAA2C;AAC3C,eAAO,MAAM,oBAAoB,eAAiC,CAAC;AAEnE,2CAA2C;AAC3C,eAAO,MAAM,4BAA4B,eAAyC,CAAC"}

package/dist/services/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Injection tokens for AtomicQueues module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATOMIC_QUEUES_MODULE_OPTIONS = exports.ATOMIC_QUEUES_CONFIG = exports.ATOMIC_QUEUES_REDIS = void 0;
+/** Redis client injection token */
+exports.ATOMIC_QUEUES_REDIS = Symbol('ATOMIC_QUEUES_REDIS');
+/** Module configuration injection token */
+exports.ATOMIC_QUEUES_CONFIG = Symbol('ATOMIC_QUEUES_CONFIG');
+/** Async module options injection token */
+exports.ATOMIC_QUEUES_MODULE_OPTIONS = Symbol('ATOMIC_QUEUES_MODULE_OPTIONS');
+//# sourceMappingURL=constants.js.map

package/dist/services/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/services/constants.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,mCAAmC;AACtB,QAAA,mBAAmB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;AAEjE,2CAA2C;AAC9B,QAAA,oBAAoB,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAEnE,2CAA2C;AAC9B,QAAA,4BAA4B,GAAG,MAAM,CAAC,8BAA8B,CAAC,CAAC"}

package/dist/services/cron-manager/cron-manager.service.d.ts

@@ -0,0 +1,188 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import Redis from 'ioredis';
+import { ICronManager, IEntityScalingConfig, IScalingDecision, IAtomicQueuesModuleConfig } from '../../domain';
+import { WorkerManagerService } from '../worker-manager';
+import { IndexManagerService } from '../index-manager';
+import { ServiceQueueManager } from '../service-queue';
+/**
+ * CronManagerService
+ *
+ * Manages worker lifecycle through periodic scaling cycles.
+ * Implements the patterns from both Whatsapi's CronqProcessor and
+ * bl-blackjack-service's WorkerManagerProcessor.
+ *
+ * Key Features:
+ * - Automatic worker spawning when jobs are queued
+ * - Worker termination when queues are empty
+ * - Concurrency limits based on entity configuration
+ * - Queue cleanup after all work is done
+ * - Excess worker handling
+ *
+ * Architecture:
+ * - Runs on a configurable interval
+ * - Each entity type can register its own scaling logic
+ * - Supports per-entity concurrency limits
+ * - Integrates with WorkerManager for worker lifecycle
+ * - Integrates with IndexManager for state tracking
+ *
+ * @example
+ * ```typescript
+ * // Register entity scaling configuration
+ * cronManager.registerEntityType({
+ *   entityType: 'user',
+ *   getDesiredWorkerCount: async (userId) => {
+ *     const plan = await getUserPlan(userId);
+ *     return planConcurrencyMap[plan];
+ *   },
+ *   getActiveEntityIds: async () => {
+ *     return indexManager.getEntitiesWithJobs('user');
+ *   },
+ *   maxWorkersPerEntity: 5,
+ *   onSpawnWorker: async (userId) => {
+ *     await commandBus.execute(new CreateUserWorkerCommand(userId));
+ *   },
+ * });
+ *
+ * // Start the cron manager
+ * cronManager.start(5000); // Run every 5 seconds
+ * ```
+ */
+export declare class CronManagerService implements ICronManager, OnModuleDestroy {
+    private readonly redis;
+    private readonly config;
+    private readonly workerManager;
+    private readonly indexManager;
+    private readonly serviceQueueManager?;
+    private readonly logger;
+    private readonly entityConfigs;
+    private cronInterval;
+    private running;
+    private readonly keyPrefix;
+    private readonly useServiceQueue;
+    private scalingHandlerRegistered;
+    constructor(redis: Redis, config: IAtomicQueuesModuleConfig, workerManager: WorkerManagerService, indexManager: IndexManagerService, serviceQueueManager?: ServiceQueueManager | undefined);
+    /**
+     * Register the scaling cycle handler with ServiceQueueManager.
+     * This ensures scaling cycles are processed atomically by the service worker.
+     */
+    private registerScalingHandler;
+    /**
+     * Register an entity type for automatic scaling.
+     */
+    registerEntityType(config: IEntityScalingConfig): void;
+    /**
+     * Unregister an entity type.
+     */
+    unregisterEntityType(entityType: string): void;
+    /**
+     * Run a scaling cycle for all registered entity types.
+     *
+     * When service queue is enabled, this triggers scaling cycles through the
+     * service queue to ensure atomic processing by the single service worker.
+     * This prevents race conditions in distributed deployments.
+     *
+     * IMPORTANT: Only the service worker owner node triggers scaling cycles.
+     * Other nodes skip the trigger to prevent duplicate jobs.
+     *
+     * This is the main logic that:
+     * 1. Gets entities with queued jobs
+     * 2. Gets entities with running workers
+     * 3. Calculates scaling decisions
+     * 4. Spawns missing workers
+     * 5. Terminates excess workers
+     * 6. Cleans up empty queues
+     */
+    runScalingCycle(): Promise<IScalingDecision[]>;
+    /**
+     * Trigger scaling cycles through the service queue.
+     * This ensures only the service worker processes scaling decisions.
+     */
+    private triggerScalingCyclesThroughServiceQueue;
+    /**
+     * Run scaling cycles directly (single instance or fallback mode).
+     */
+    private runScalingCycleDirectly;
+    /**
+     * Get current scaling state for all entity types.
+     */
+    getScalingState(): Promise<Map<string, IScalingDecision[]>>;
+    /**
+     * Start the cron manager.
+     */
+    start(intervalMs?: number): void;
+    /**
+     * Stop the cron manager.
+     */
+    stop(): void;
+    /**
+     * Check if cron manager is running.
+     */
+    isRunning(): boolean;
+    /**
+     * Cleanup on module destroy.
+     */
+    onModuleDestroy(): void;
+    /**
+     * Run scaling cycle for a specific entity type.
+     * This is the internal implementation called either directly or via service queue.
+     */
+    private runEntityScalingCycleInternal;
+    /**
+     * Handle worker spawning for an entity.
+     */
+    private handleEntitySpawning;
+    /**
+     * Handle excess workers for an entity.
+     */
+    private handleExcessWorkers;
+    /**
+     * Handle worker closure for entities with no jobs.
+     * Only terminates workers if the entity's queue is truly empty (no waiting or active jobs).
+     */
+    private handleWorkerClosure;
+    /**
+     * Check if a queue has any waiting or active jobs.
+     */
+    private checkQueueHasJobs;
+    /**
+     * Handle queue cleanup for entities with no jobs and no workers.
+     */
+    private handleQueueCleanup;
+    /**
+     * Queue worker termination via the entity's queue.
+     */
+    private queueWorkerTermination;
+    /**
+     * Get the number of workers for an entity.
+     * Uses the worker heartbeat TTL keys as the single source of truth.
+     * This is a direct Redis query - no service queue needed since we're just reading keys.
+     */
+    private getEntityWorkerCount;
+    /**
+     * Get all entities with workers.
+     * Uses the worker heartbeat TTL keys as the single source of truth.
+     * Worker names follow pattern: {entityId}-worker
+     */
+    private getEntitiesWithWorkers;
+    /**
+     * Get pending worker creation requests count.
+     */
+    private getPendingWorkerCreations;
+    /**
+     * Increment worker creation request counter.
+     */
+    private incrementWorkerCreationRequest;
+    /**
+     * Decrement worker creation request counter.
+     */
+    decrementWorkerCreationRequest(entityType: string, entityId: string): Promise<void>;
+    /**
+     * Determine the scaling action based on current vs desired.
+     */
+    private determineAction;
+    /**
+     * Scan Redis keys matching a pattern.
+     */
+    private scanKeys;
+}
+//# sourceMappingURL=cron-manager.service.d.ts.map

package/dist/services/cron-manager/cron-manager.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-manager.service.d.ts","sourceRoot":"","sources":["../../../src/services/cron-manager/cron-manager.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,eAAe,EAAY,MAAM,gBAAgB,CAAC;AACvF,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAwB,MAAM,kBAAkB,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,qBACa,kBAAmB,YAAW,YAAY,EAAE,eAAe;IAUvC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAEnD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IACjB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IAdnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgD;IAC9E,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,wBAAwB,CAAS;gBAGO,KAAK,EAAE,KAAK,EAEzC,MAAM,EAAE,yBAAyB,EACjC,aAAa,EAAE,oBAAoB,EACnC,YAAY,EAAE,mBAAmB,EACrB,mBAAmB,CAAC,EAAE,mBAAmB,YAAA;IAUxE;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAsB9B;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI;IAKtD;;OAEG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAK9C;;;;;;;;;;;;;;;;;OAiBG;IACG,eAAe,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAepD;;;OAGG;YACW,uCAAuC;IAYrD;;OAEG;YACW,uBAAuB;IAoBrC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;IA8BjE;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IA0BhC;;OAEG;IACH,IAAI,IAAI,IAAI;IASZ;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,eAAe,IAAI,IAAI;IAQvB;;;OAGG;YACW,6BAA6B;IAmD3C;;OAEG;YACW,oBAAoB;IAsDlC;;OAEG;YACW,mBAAmB;IAuCjC;;;OAGG;YACW,mBAAmB;IA8CjC;;OAEG;YACW,iBAAiB;IAyB/B;;OAEG;YACW,kBAAkB;IAqBhC;;OAEG;YACW,sBAAsB;IAapC;;;;OAIG;YACW,oBAAoB;IAYlC;;;;OAIG;YACW,sBAAsB;IAqBpC;;OAEG;YACW,yBAAyB;IASvC;;OAEG;YACW,8BAA8B;IAS5C;;OAEG;IACG,8BAA8B,CAClC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACH,OAAO,CAAC,eAAe;IASvB;;OAEG;YACW,QAAQ;CAkBvB"}