MonqueTsedConfig

Configuration options for @monque/tsed.

Extends MonqueOptions with Ts.ED-specific settings for database resolution and module behavior.

Example

@Configuration({
  monque: {
    db: mongoClient.db("myapp"),
    collectionName: "jobs",
    defaultConcurrency: 5
  }
})
export class Server {}

Extends

MonqueOptions

Properties

baseRetryInterval?

optional baseRetryInterval: number;

Defined in: core/dist/index.d.mts:664

Base interval in milliseconds for exponential backoff calculation. Actual delay = 2^failCount * baseRetryInterval

Default

Inherited from

MonqueOptions.baseRetryInterval

collectionName?

optional collectionName: string;

Defined in: core/dist/index.d.mts:648

Name of the MongoDB collection for storing jobs.

Default

'monque_jobs'

Inherited from

MonqueOptions.collectionName

db?

optional db: Db;

Defined in: tsed/src/config/types.ts:55

Direct MongoDB database instance.

Use when you have a pre-connected Db object available synchronously.

Example

@Configuration({
  monque: {
    db: mongoClient.db("myapp"),
    collectionName: "jobs"
  }
})

dbFactory()?

optional dbFactory: () => Db | Promise<Db>;

Defined in: tsed/src/config/types.ts:75

Factory function to create the database connection.

Called once during module initialization. Supports async factories for connection pooling or lazy initialization.

Returns

Db | Promise<Db>

Example

@Configuration({
  monque: {
    dbFactory: async () => {
      const client = await MongoClient.connect(process.env.MONGO_URI!);
      return client.db("myapp");
    }
  }
})

dbToken?

optional dbToken: TokenProvider<Db>;

Defined in: tsed/src/config/types.ts:104

DI token to inject the Db instance from the container.

Use when your application already has a MongoDB provider registered in the DI container.

Can also be used to inject a MongooseService or Connection.

Example

// First, register a MongoDB provider
registerProvider({
  provide: "MONGODB_DATABASE",
  useFactory: async () => {
    const client = await MongoClient.connect(uri);
    return client.db("myapp");
  }
});

// Then reference it in config
@Configuration({
  monque: {
    dbToken: "MONGODB_DATABASE"
  }
})

defaultConcurrency?

optional defaultConcurrency: number;

Defined in: core/dist/index.d.mts:693

Default number of concurrent jobs per worker.

Default

Inherited from

MonqueOptions.defaultConcurrency

disableJobProcessing?

optional disableJobProcessing: boolean;

Defined in: tsed/src/config/types.ts:146

Disable job processing on this instance.

When true, the module will initialize the database connection (allowing you to enqueue jobs via MonqueService) but will NOT register jobs or start the polling loop. Useful for “Producer-only” nodes like API servers that only enqueue jobs but don’t process them.

Example

// API Server (Producer-only)
@Configuration({
  monque: {
    dbFactory: async () => client.db('myapp'),
    disableJobProcessing: true, // Only enqueue, don't process
  }
})
export class ApiServer {}

// Job Server (Consumer)
@Configuration({
  monque: {
    dbFactory: async () => client.db('myapp'),
    // disableJobProcessing defaults to false - processes jobs
  }
})
export class JobServer {}

Default

false

enabled?

optional enabled: boolean;

Defined in: tsed/src/config/types.ts:38

Enable or disable the Monque module.

When disabled:

Jobs are not registered
Lifecycle hooks are no-ops
MonqueService throws on access

Default

true

heartbeatInterval?

optional heartbeatInterval: number;

Defined in: core/dist/index.d.mts:718

Interval in milliseconds for heartbeat updates during job processing. The scheduler periodically updates lastHeartbeat for all jobs it is processing to indicate liveness for monitoring/debugging.

Note: stale recovery is based on lockedAt + lockTimeout, not lastHeartbeat.

Default

30000 (30 seconds)

Inherited from

MonqueOptions.heartbeatInterval

instanceConcurrency?

optional instanceConcurrency: number;

Defined in: core/dist/index.d.mts:766

Maximum number of concurrent jobs processed by this instance across all registered workers.

If reached, the scheduler will stop claiming new jobs until active jobs complete. Use this to prevent a single instance from overwhelming system resources.

Note: This is an instance-level limit. Each worker still respects its own concurrency setting, but the total across all workers cannot exceed this limit.

Example

const monque = new Monque(db, {
  instanceConcurrency: 10, // Instance processes max 10 jobs total
  workerConcurrency: 5,    // Each worker defaults to 5 concurrent jobs
});

// With 3 workers at concurrency 5, normally 15 jobs could run.
// With instanceConcurrency: 10, only 10 jobs run at any time.

Inherited from

MonqueOptions.instanceConcurrency

jobRetention?

optional jobRetention: object;

Defined in: core/dist/index.d.mts:729

Configuration for automatic cleanup of completed and failed jobs. If undefined, no cleanup is performed.

completed?

optional completed: number;

Age in milliseconds after which completed jobs are deleted. Cleaned up based on ‘updatedAt’ timestamp.

failed?

optional failed: number;

Age in milliseconds after which failed jobs are deleted. Cleaned up based on ‘updatedAt’ timestamp.

interval?

optional interval: number;

Interval in milliseconds for running the cleanup job.

Default

3600000 (1 hour)

Inherited from

MonqueOptions.jobRetention

lockTimeout?

optional lockTimeout: number;

Defined in: core/dist/index.d.mts:702

Maximum time in milliseconds a job can be in ‘processing’ status before being considered stale and eligible for recovery.

Stale recovery uses lockedAt as the source of truth; this is an absolute “time locked” limit, not a heartbeat timeout.

Default

1800000 (30 minutes)

Inherited from

MonqueOptions.lockTimeout

maxBackoffDelay?

optional maxBackoffDelay: number;

Defined in: core/dist/index.d.mts:672

Maximum delay in milliseconds for exponential backoff. If calculated delay exceeds this value, it will be capped.

Defaults to 24 hours to prevent unbounded delays.

Default

86400000 (24 hours)

Inherited from

MonqueOptions.maxBackoffDelay

maxConcurrency?

optional maxConcurrency: number;

Defined in: core/dist/index.d.mts:772

Maximum number of concurrent jobs processed by this instance across all registered workers.

Inherited from

MonqueOptions.maxConcurrency

maxRetries?

optional maxRetries: number;

Defined in: core/dist/index.d.mts:658

Maximum number of retry attempts before marking a job as permanently failed.

Default

Inherited from

MonqueOptions.maxRetries

mongooseConnectionId?

optional mongooseConnectionId: string;

Defined in: tsed/src/config/types.ts:113

Connection ID of the Mongoose connection to use.

Requires the use of dbToken pointing to MongooseService.

Default

"default"

pollInterval?

optional pollInterval: number;

Defined in: core/dist/index.d.mts:653

Interval in milliseconds between polling for new jobs.

Default

Inherited from

MonqueOptions.pollInterval

recoverStaleJobs?

optional recoverStaleJobs: boolean;

Defined in: core/dist/index.d.mts:724

Whether to recover stale processing jobs on scheduler startup. When true, jobs with lockedAt older than lockTimeout will be reset to pending.

Default

true

Inherited from

MonqueOptions.recoverStaleJobs

schedulerInstanceId?

optional schedulerInstanceId: string;

Defined in: core/dist/index.d.mts:709

Unique identifier for this scheduler instance. Used for atomic job claiming - each instance uses this ID to claim jobs. Defaults to a randomly generated UUID v4.

Default

crypto.randomUUID()

Inherited from

MonqueOptions.schedulerInstanceId

shutdownTimeout?

optional shutdownTimeout: number;

Defined in: core/dist/index.d.mts:677

Timeout in milliseconds for graceful shutdown.

Default

Inherited from

MonqueOptions.shutdownTimeout

workerConcurrency?

optional workerConcurrency: number;

Defined in: core/dist/index.d.mts:686

Default number of concurrent jobs per worker.

This is the per-worker concurrency limit applied when a worker is registered without specifying its own concurrency option.

Default

Inherited from

MonqueOptions.workerConcurrency