- The modern MongoDB-powered scheduling library for Node.js
-
-
-
-
-
-
-
-
-
-
+# What is Pulse?
-
-
- Table of Contents
+
-- [Overview](#overview)
- - [Related Projects](#related-projects)
-- [Features](#features)
-- [Repository Structure](#repository-structure)
-- [Modules](#modules)
-- [Getting Started](#getting-started)
- - [Installation](#installation)
- - [Example](#example)
-- [Project Roadmap](#project-roadmap)
-- [Contributing](#contributing)
-- [License](#license)
-- [Acknowledgments](#acknowledgments)
-
-
+## **Definition and Context**:
-## Overview
+* Pulse is an open-source job scheduling tool in the Node.js ecosystem, serving as a fork of the discontinued Agenda project.
+* Utilizes MongoDB for managing job data, which enhances its ability to perform at scale.
-Pulse is a new fork of the [Agenda](https://github.com/agenda/agenda) project, created as the original project is no longer actively maintained. Positioned as a vital solution in the Node.js ecosystem for job scheduling, the hiatus of Agenda prompted the creation of Pulse. Utilizing MongoDB, Pulse introduces advanced functionalities, improved scalability, and contemporary features to address today’s complex scheduling challenges.
+## **Core Features**:
-
+* **High Scalability**: Handles numerous jobs efficiently, suitable for applications that need to manage extensive workloads.
+* **Modern Architecture**: Leverages the latest Node.js features and incorporates best practices for optimal performance.
+* **Flexible Scheduling**: Supports various types of job schedules, including complex cron patterns and one-time executions.
+* **Seamless Integration**: Designed to integrate effortlessly with Node.js applications and existing MongoDB databases.
-#### Related Projects
-- [pulsecron](https://www.pulsecron.com) - Event-driven task scheduling management infrastructure
-- [nestjs-pulse](https://github.com/pulsecron/nestjs-pulse) - official NestJS module for Pulse.
+## **Related Projects**:
----
+* [**pulsecron**](https://www.pulsecron.com): Provides an event-driven task scheduling management infrastructure.
+* [**nestjs-pulse**](https://github.com/pulsecron/nestjs-pulse): An official NestJS module specifically tailored for integrating Pulse into NestJS applications.
-
-
+## **Usage and Application**:
-
-## Features
-
-- **High Scalability**: Designed to efficiently manage large-scale job processing.
-- **Modern Architecture**: Employs the latest Node.js features and best practices for superior performance.
-- **Flexible Scheduling**: Offers support for cron, one-time, and recurring jobs with fine-tuned control.
-- **Seamless Integration**: Easily integrates with existing Node.js applications and MongoDB setups.
-- **Extensive Documentation**: Provides detailed guides and examples for a quick and easy start.
-
----
-
-
-
-## Repository Structure
-
-```sh
-└── pulse/
- ├── LICENSE
- ├── README.md
- ├── es.js
- ├── examples
- │ └── concurrency.ts
- ├── package-lock.json
- ├── package.json
- ├── src
- │ ├── cjs.ts
- │ ├── index.ts
- │ ├── job
- │ ├── pulse
- │ └── utils
- ├── tsconfig.eslint.json
- └── tsconfig.json
-```
-
----
-
-
-
-## Modules
-
-src.pulse
-
-| File | Summary |
-| --- | --- |
-| [has-mongo-protocol.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/has-mongo-protocol.ts) | HasMongoProtocol establishes a function that evaluates if a given URL string contains a valid MongoDB connection protocol, contributing to the repositorys ability to handle and verify database connections. |
-| [default-concurrency.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/default-concurrency.ts) | Sets the default concurrency for each job within the Pulse open-source project by modifying the internal state. It contributes to the task scheduling and management functionalities in the project. |
-| [name.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/name.ts) | Sets the name of a queue within the Pulse object in the parent repositorys architecture. It utilizes debugging for traceability and maintains the flow architecture by returning the Pulse instance after the name assignment. |
-| [drain.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/drain.ts) | Drain.ts serves a crucial role in the Pulse module, enabling the cancellation of ongoing job processes. It ensures that all running jobs get completed before terminating the processing interval, promoting an efficient and orderly execution flow in the application. |
-| [enable.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/enable.ts) | Enables specific jobs within the Pulse module by toggling the disabled flag to false. Utilizes MongoDB queries to precisely select matching jobs, aspiring to enhance the flexibility and robustness of job execution. Returns the count of jobs successfully enabled, aiding in operational tracking. |
-| [schedule.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/schedule.ts) | Schedule.ts within the Pulse directory facilitates job scheduling for specific timings. Through this module, users can assign an array of job names to be executed at a specified time, along with associated data. Multiple jobs can be created at once, enhancing the efficiency of task management in the repository. |
-| [default-lock-lifetime.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/default-lock-lifetime.ts) | Establishes the default lock lifetime in a Pulse application. It allows setting the default lock time in milliseconds, providing flexibility in managing task execution timelines. This is a critical feature for handling concurrency control in Pulses job processing system. |
-| [db-init.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/db-init.ts) | Establishes and initializes the database collection for job management in the Pulse open-source project. It also includes optional index creation functionality, providing efficient job searching within the database. Notifiers for success or errors make the process transparent and manageable. |
-| [process-every.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/process-every.ts) | ProcessEvery sets a default interval for a Pulse objects processing time. It leverages human-readable time intervals to determine the frequency of certain operations within the pulse directory of the repository. This function returns the updated Pulse object. |
-| [disable.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/disable.ts) | Disables selected jobs in the Pulse application by applying a MongoDB filter query. The function returns the number of successfully disabled job instances, providing enhanced control over task execution. |
-| [jobs.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/jobs.ts) | Within the Pulse repository, the jobs.ts script from the src/pulse directory performs a crucial task. It retrieves all jobs matching a certain query from a MongoDB collection, with options for sorting, limiting and skipping results, transforming these into job objects before returning. |
-| [start.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/start.ts) | Start.ts initializes job processing for the Pulse module. It validates system readiness before periodically processing tasks using the processJobs method from the utils directory. The method ensures job execution regularity and guarantees uninterrupted operation, provided a database is set beforehand. |
-| [every.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/every.ts) | Within the pulse directory, every.ts establishes a regular job execution framework. It enables job scheduling at specified intervals, handling singular and multiple job names. Pertinent debugging information for scheduled job processes is also provided by this module. |
-| [max-concurrency.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/max-concurrency.ts) | MaxConcurrency controls job execution in the Pulse system by globally setting the maximum concurrency value, thereby optimizing task management. It directly interacts with the core Pulse framework, ensuring that job execution does not exceed the defined threshold, enhancing overall process efficiency. |
-| [purge.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/purge.ts) | Purge.ts, within the pulse subdirectory, provides functionality to remove all jobs from the queue in the Pulse application. It exports an asynchronous function that cancels undefined jobs, ensuring only defined jobs remain. The function's outcome is confirmed with success or failure notifications. |
-| [now.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/now.ts) | Establishes a function within the Pulse module, designed to create a job task instantly. This function, named now, accepts job details, schedules it for the current time, saves the job into the system, and handles potential creation errors. |
-| [default-lock-limit.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/default-lock-limit.ts) | Defines the maximum number of locks per job type in the Pulse system. It establishes a default limit, with each instance adjustable per user needs. The limit optimizes concurrent task handling, enhancing overall application performance. |
-| [stop.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/stop.ts) | Stop.ts within the Pulse sub-directory is responsible for terminating the process of job execution. It achieves this by unlocking jobs that were locked for processing, allowing them to be re-run or accessed, and by clearing the job execution interval, effectively stopping further job processing. |
-| [database.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/database.ts) | Database.ts, located in the src/pulse directory, establishes a connection to a specified MongoDB server. It features the flexibility to use an existing MongoDB connection, customize collection names, and handle connection errors. Ultimately, this file integrates MongoDB into the broader Pulse architecture. |
-| [sort.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/sort.ts) | Sort.ts orchestrates the sorting functionality within the Pulse component, allowing users to customize their queries for job searches. It primarily manages the rules for prioritizing and scheduling jobs, with the default being jobs sorted by their next run time and priority. |
-| [mongo.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/mongo.ts) | Mongo.ts integrates MongoDB with the Pulse application, enabling the establishment of database connections. It provides a method to inject MongoClient instance, specify the collection, and handle database initialization errors through callbacks. |
-| [cancel.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/cancel.ts) | Cancel.ts facilitates the termination of specific Pulse jobs based on a provided MongoDB query, effectively removing them from the database. These cancellations can be initiated by the client code, the Pulse.purge() function, or the Job.remove() function. |
-| [index.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/index.ts) | Pulse, the heart of the repository, manages a queue of jobs in a MongoDB collection. This task scheduling system facilitates job creation, scheduling, locking, and execution, handling concurrency defaults, lock limits, and durations. Moreover, it supports optional configuration and customization parameters. |
-| [define.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/define.ts) | Defines job parameters and execution procedures in the Pulse library. Users can configure concurrency, locking, priority, lifetime, and result persistence for a named job. Job definitions are stored and debugged for future execution within the Pulse system. |
-| [create.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/create.ts) | Creates new jobs within the Pulse module of the repository. This piece of code initializes these jobs with given names and data, also setting specific attributes such as priority and whether to save results based on predefined definitions. |
-| [find-and-lock-next-job.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/find-and-lock-next-job.ts) | Unlocks and processes queued jobs within the Pulse repository. In the find-and-lock-next-job file, the function identifies a specific job based on its name, locks it for execution, and returns the job status. This operation ensures efficient management of tasks within the system. |
-| [job-processing-queue.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/job-processing-queue.ts) | JobProcessingQueue, as part of the larger Pulse repository, manages job processing through an internal queue. It offers capabilities like job insertion in a specific order, popping jobs without concurrency checks, and identifying the next job eligible for processing whose execution isnt blocked by concurrency. |
-| [lock-limit.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/lock-limit.ts) | LockLimit sets a global upper limit on the number of jobs that can be simultaneously locked within the Pulse system, ensuring efficient task execution without resource overstretching. Its essential for maintaining concurrency control in the broader repository architecture. |
-| [close.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/close.ts) | Pulse/close.ts secures the main functionality of closing database connections within the Pulse project. It incorporates a provision for forcefully closing connections and handles exceptions that might arise during this process. The feature is specifically adapted for MongoDB databases that havent been preconfigured. |
-| [save-job.ts](https://github.com/pulsecron/pulse/blob/master/src/pulse/save-job.ts) | ► INSERT-TEXT-HERE |
-
-
-
-src.utils
-
-| File | Summary |
-| --- | --- |
-| [parse-priority.ts](https://github.com/pulsecron/pulse/blob/master/src/utils/parse-priority.ts) | ParsePriority, situated in the src/utils folder, transforms the priority of jobs from a textual format to a numerical representation. This allows the Pulse system within the repository to handle job scheduling based on priority levels, improving task queue management. |
-| [process-jobs.ts](https://github.com/pulsecron/pulse/blob/master/src/utils/process-jobs.ts) | ► INSERT-TEXT-HERE |
-| [create-job.ts](https://github.com/pulsecron/pulse/blob/master/src/utils/create-job.ts) | CreateJob function, residing in src/utils/create-job.ts, orchestrates the generation of Job objects within the Pulse application. It complements the parent repositorys architecture by leveraging the Pulse instance and supplied job data to construct and return a Job. |
-| [index.ts](https://github.com/pulsecron/pulse/blob/master/src/utils/index.ts) | Facilitates job creation, priority parsing, and job processing, serving as a utility hub within the pulse repository. It critically interlinks these utility functions to streamline task organization and execution, enhancing the repository's overall functionality. |
-
-
-
-src.job
-
-| File | Summary |
-| --- | --- |
-| [enable.ts](https://github.com/pulsecron/pulse/blob/master/src/job/enable.ts) | Enable.ts activates a specific job type within the pulse project. By modifying an attribute in the Job object, it reverses the disabled status, allowing the job to run. This function integrates seamlessly with the wider repository structure, particularly the job module. |
-| [is-running.ts](https://github.com/pulsecron/pulse/blob/master/src/job/is-running.ts) | Defines a function that determines if specific jobs within the application are currently running. It uses time comparisons, analyzing lastRunAt and lastFinishedAt properties, to deliver its verdict, thereby enhancing task management in the parent repository pulse. |
-| [schedule.ts](https://github.com/pulsecron/pulse/blob/master/src/job/schedule.ts) | Schedule.ts in the job directory empowers a certain task to run at a predefined time. Using this feature, users can set either a specific date or a string pattern to determine the next execution instance of a job, thereby enhancing the scheduling capabilities in the overall Pulse project. |
-| [touch.ts](https://github.com/pulsecron/pulse/blob/master/src/job/touch.ts) | Touch.ts within the job directory of the Pulse repository manages job concurrency. It updates a jobs lockedAt time, preventing multiple instances from running simultaneously. The function returns a Promise for the saved job. |
-| [compute-next-run-at.ts](https://github.com/pulsecron/pulse/blob/master/src/job/compute-next-run-at.ts) | ► INSERT-TEXT-HERE |
-| [to-json.ts](https://github.com/pulsecron/pulse/blob/master/src/job/to-json.ts) | Transforms job details into a storable JSON object within the repositorys job management module. Converts key date attributes into the Date data type, facilitating data interchange with MongoDB. |
-| [repeat-at.ts](https://github.com/pulsecron/pulse/blob/master/src/job/repeat-at.ts) | RepeatAt is a functionality of the Job module that arranges a task repetition at a specific interval. It accepts human-readable or numeric time variables, thereby empowering developers to schedule tasks dynamically within the pulse project. |
-| [set-shouldsaveresult.ts](https://github.com/pulsecron/pulse/blob/master/src/job/set-shouldsaveresult.ts) | SetShouldSaveResult in the Job directory enables the persistence of a jobs return value by managing the relevant flag. It forms part of the repositorys core functionality, influencing how job results are stored and retrieved within the pulse system. |
-| [disable.ts](https://github.com/pulsecron/pulse/blob/master/src/job/disable.ts) | Acting as a crucial component in the pulse repository, src/job/disable.ts provides the functionality to prevent specific jobs from running within the software system by modifying the job attributes. The solution enhances system control and ensures efficient resource allocation. |
-| [fail.ts](https://github.com/pulsecron/pulse/blob/master/src/job/fail.ts) | Fail within the job directory of the Pulse repository ensures efficient error handling by marking a job as failed. It records the failure reason, increments the failure count, timestamps it, and debugs the number of times a job has failed, thereby improving transparency and traceability. |
-| [priority.ts](https://github.com/pulsecron/pulse/blob/master/src/job/priority.ts) | In the context of the Pulse repository, priority.ts facilitates adjustment of task prioritization within the job queue. It leverages a method to parse and set job priority based on provided parameters, thereby influencing the order of job execution. |
-| [remove.ts](https://github.com/pulsecron/pulse/blob/master/src/job/remove.ts) | In the context of the Pulse repository, remove.ts distresses a crucial function within the Job module. It facilitates the removal of a job from MongoDB by cancelling the job identified by its unique _id attribute. |
-| [unique.ts](https://github.com/pulsecron/pulse/blob/master/src/job/unique.ts) | Within the broader Pulse repository, the unique.ts file fundamentally manages the uniqueness of a job. It contains a function that allows the creation of unique jobs by adding specific unique attributes and options to the job data. |
-| [index.ts](https://github.com/pulsecron/pulse/blob/master/src/job/index.ts) | ► INSERT-TEXT-HERE |
-| [repeat-every.ts](https://github.com/pulsecron/pulse/blob/master/src/job/repeat-every.ts) | RepeatEvery, located within the job directory, enables task scheduling at regular intervals. It includes versatile options such as setting start dates, end dates, skipping specific days, and handling immediate execution scenarios, contributing significantly to the parent repository's task management capabilities. |
-| [run.ts](https://github.com/pulsecron/pulse/blob/master/src/job/run.ts) | ► INSERT-TEXT-HERE |
-| [save.ts](https://github.com/pulsecron/pulse/blob/master/src/job/save.ts) | Save.ts facilitates the persistence of job instances into MongoDB. Working within the job subdirectory of the pulse project, it enables asynchronous saving operations, either successfully storing a job or returning errors. |
-
-
-
----
-
-
-
-## Getting Started
-
-
-
-#### Installation
-
- ```console
- $ npm install --save @pulsecron/pulse
-```
-
-
-
-#### Example
-
-```typescript
-import Pulse from '@pulsecron/pulse';
-
-const mongoConnectionString = 'mongodb://localhost:27017/pulse';
-
-const pulse = new Pulse({ db: { address: mongoConnectionString } });
-
-// Or override the default collection name:
-// const pulse = new Pulse({db: {address: mongoConnectionString, collection: 'jobCollectionName'}});
-
-// or pass additional connection options:
-// const pulse = new Pulse({db: {address: mongoConnectionString, collection: 'jobCollectionName', options: {ssl: true}}});
-
-// or pass in an existing mongodb-native MongoClient instance
-// const pulse = new Pulse({mongo: myMongoClient});
-
-/**
- * Example of defining a job
- */
-pulse.define('delete old users', async (job) => {
- console.log('Deleting old users...');
- return;
-});
-
-/**
- * Example of repeating a job
- */
-(async function () {
- // IIFE to give access to async/await
- await pulse.start();
-
- await pulse.every('3 minutes', 'delete old users');
-
- // Alternatively, you could also do:
- await pulse.every('*/3 * * * *', 'delete old users');
-})();
-
-/**
- * Example of defining a job with options
- */
-pulse.define(
- 'send email report',
- async (job) => {
- const { to } = job.attrs.data;
-
- console.log(`Sending email report to ${to}`);
- },
- { lockLifetime: 5 * 1000, priority: 'high', concurrency: 10 }
-);
-
-/**
- * Example of scheduling a job
- */
-(async function () {
- await pulse.start();
- await pulse.schedule('in 20 minutes', 'send email report', { to: 'admin@example.com' });
-})();
-
-/**
- * Example of repeating a job
- */
-(async function () {
- const weeklyReport = pulse.create('send email report', { to: 'example@example.com' });
- await pulse.start();
- await weeklyReport.repeatEvery('1 week').save();
-})();
-
-/**
- * Check job start and completion/failure
- */
-pulse.on('start', (job) => {
- console.log(time(), `Job <${job.attrs.name}> starting`);
-});
-pulse.on('success', (job) => {
- console.log(time(), `Job <${job.attrs.name}> succeeded`);
-});
-pulse.on('fail', (error, job) => {
- console.log(time(), `Job <${job.attrs.name}> failed:`, error);
-});
-
-function time() {
- return new Date().toTimeString().split(' ')[0];
-}
-
-
-```
-
-
----
-
-
-
-## Project Roadmap
-
-- [X] **Add Support for Latest Mongoose Version(8.x.x)**: Upgrade Pulse to be fully compatible with the latest version of Mongoose. This will enable Pulse to leverage the newest features and improvements in Mongoose, ensuring better performance, stability, and security for applications that rely on MongoDB through Mongoose.
-- [ ] **Refactoring to Modern TypeScript Syntax**: Undertake a comprehensive refactor of the codebase to utilize modern TypeScript features and syntax. This refactoring will improve code readability, maintainability, and make it easier for new contributors to understand and contribute to the project.
-- [ ] **Resolving Issues in Existing Agenda Projects**: Actively address and resolve outstanding issues within the original Agenda project. This initiative not only aids the community by improving the legacy codebase but also informs the development of Pulse by identifying and addressing past challenges.
-- [ ] **Rewrite Test Code**: Revamp our testing suite to increase coverage and ensure tests are up-to-date with modern testing practices. This rewrite aims to enhance test reliability and efficiency, facilitating smoother development and deployment cycles.
-- [ ] **Rewrite Documentation**: Completely revise and update the documentation to reflect all new changes and features, ensure clarity of information, and improve navigation and readability for developers. This effort will include new getting started guides, API documentation, and use case examples to facilitate easier adoption and implementation by users.
----
-
-
-
-## Contributing
-
-Contributions are welcome! Here are several ways you can contribute:
-
-- **[Report Issues](https://github.com/pulsecron/pulse/issues)**: Submit bugs found or log feature requests for the `pulse` project.
-- **[Submit Pull Requests](https://github.com/pulsecron/pulse/pulls)**: Review open PRs, and submit your own PRs.
-- **[Join the Discussions](https://github.com/pulsecron/pulse/discussions)**: Share your insights, provide feedback, or ask questions.
-
-
-Contributing Guidelines
-
-1. **Fork the Repository**: Start by forking the project repository to your github account.
-2. **Clone Locally**: Clone the forked repository to your local machine using a git client.
- ```sh
- git clone https://github.com/pulsecron/pulse
- ```
-3. **Create a New Branch**: Always work on a new branch, giving it a descriptive name.
- ```sh
- git checkout -b new-feature-x
- ```
-4. **Make Your Changes**: Develop and test your changes locally.
-5. **Commit Your Changes**: Commit with a clear message describing your updates.
- ```sh
- git commit -m 'Implemented new feature x.'
- ```
-6. **Push to github**: Push the changes to your forked repository.
- ```sh
- git push origin new-feature-x
- ```
-7. **Submit a Pull Request**: Create a PR against the original project repository. Clearly describe the changes and their motivations.
-8. **Review**: Once your PR is reviewed and approved, it will be merged into the main branch. Congratulations on your contribution!
-
-
-
-Contributor Graph
-
-
-
-
----
-
-
-
-## License
-
-This project is protected under the [MIT](https://github.com/pulsecron/pulse?tab=MIT-1-ov-file#readme) License. For more details, refer to the [LICENSE](https://github.com/pulsecron/pulse?tab=MIT-1-ov-file#readme) file.
-
----
-
-
-
-
-## Acknowledgments
-- Pulse was forked from [Agenda](https://github.com/agenda/agenda) by [@pulsecron](https://github.com/pulsecron).
+* Ideal for developers needing a reliable, scalable, and modern job scheduling solution.
+* Applicable in scenarios ranging from simple task automation to complex job orchestration in distributed systems.
diff --git a/SUMMARY.md b/SUMMARY.md
new file mode 100644
index 0000000..565d325
--- /dev/null
+++ b/SUMMARY.md
@@ -0,0 +1,25 @@
+# Table of contents
+
+* [What is Pulse?](README.md)
+* [Why Pulse?](why-pulse.md)
+* [Quick Start](quick-start.md)
+
+## DOCS
+
+* [Setup & Config](docs/setup-and-config/README.md)
+ * [Connection](docs/setup-and-config/connection.md)
+ * [Config](docs/setup-and-config/config/README.md)
+ * [Name](docs/setup-and-config/config/name.md)
+ * [ProcessEvery](docs/setup-and-config/config/processevery.md)
+ * [DefaultConcurrency](docs/setup-and-config/config/defaultconcurrency.md)
+ * [MaxConcurrency](docs/setup-and-config/config/maxconcurrency.md)
+ * [LockLimit](docs/setup-and-config/config/locklimit.md)
+ * [DefaultLockLimit](docs/setup-and-config/config/defaultlocklimit.md)
+ * [DefaultLockLifetime](docs/setup-and-config/config/defaultlocklifetime.md)
+ * [Sort](docs/setup-and-config/config/sort.md)
+* [Defining Job Processors](docs/defining-job-processors.md)
+* [Creating Jobs](docs/creating-jobs/README.md)
+ * [Every](docs/creating-jobs/every.md)
+ * [Schedule](docs/creating-jobs/schedule.md)
+ * [Now](docs/creating-jobs/now.md)
+ * [Create](docs/creating-jobs/create.md)
diff --git a/docs/creating-jobs/README.md b/docs/creating-jobs/README.md
new file mode 100644
index 0000000..dd006d5
--- /dev/null
+++ b/docs/creating-jobs/README.md
@@ -0,0 +1,4 @@
+# Creating Jobs
+
+
+
diff --git a/docs/creating-jobs/create.md b/docs/creating-jobs/create.md
new file mode 100644
index 0000000..1716b91
--- /dev/null
+++ b/docs/creating-jobs/create.md
@@ -0,0 +1,38 @@
+# Create
+
+
+
+## `pulse.create(name, data?)`
+
+{% hint style="info" %}
+The `create` method generates a new job instance based on a specified job type and data. It is a preliminary step in the job lifecycle, allowing for the customization of job parameters before the job is scheduled and executed.\
+\
+_This does **NOT** save the job in the database._
+{% endhint %}
+
+### Example Usage
+
+```typescript
+cconst pulse = new Pulse();
+
+// Create a new job for data analysis
+const analysisJob = pulse.create('dataAnalysis', { datasetId: 101 });
+analysisJob.save()
+```
+
+
+
+#### Parameters
+
+* **`name`** (`string`): The name of the job to be created. This name should correspond to a job type previously defined with the `define` method, which dictates certain default settings such as priority and result-saving behavior.
+* **`data`** (`T`): Data to pass to the job for its execution. This data is used within the job's processing logic and can be any type of data that the job requires.
+
+#### Returns
+
+* **`Job`**: Returns a new `Job` instance configured with the provided name and data.
+
+\
+
+
+
+
diff --git a/docs/creating-jobs/every.md b/docs/creating-jobs/every.md
new file mode 100644
index 0000000..fd07baa
--- /dev/null
+++ b/docs/creating-jobs/every.md
@@ -0,0 +1,42 @@
+# Every
+
+
+
+## `pulse.every(interval, names, data?, options?)`
+
+{% hint style="info" %}
+The `every` method schedules one or more jobs to run repeatedly at specified intervals. It allows for precise control over job execution timing and can be used to schedule routine tasks such as data synchronization, report generation, or regular maintenance tasks.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set a custom sort order for job processing
+pulse.every('1 day', 'dailyReport', { reportId: 123 });
+
+// Schedule multiple jobs to run every 30 minutes
+pulse.every('30 minutes', ['updateCache', 'refreshData'], null, { skipImmediate: true });
+```
+
+
+
+#### Parameters
+
+* **`interval`** (`string`): The interval at which the job(s) should run. This can be a human-readable format, such as '5 minutes', '1 hour', a [cron format](https://www.npmjs.com/package/cron-parser) `String`, or a `Number`
+* **`names`** (`string | string[]`): The name or array of names of the job(s) to be scheduled. Each name corresponds to a job type previously defined with the `define` method.
+* **`data`** (`T` - optional): Data to pass to the job when it runs. This could be any type of data required by the job for its execution.
+* **`options`** (`JobOptions` - optional): Additional options for the job execution, such as starting the job at a specific time, setting a limit on the number of times the job should repeat, or other job-specific settings.
+ * **`timezone`** (`string` - optional): The timezone to use for scheduling the job, useful for jobs that depend on specific regional settings.
+ * **`startDate`** (`Date | number` - optional): The start date or timestamp from which the job should begin executing. _(_Only available when _interval format is a cron format)_
+ * **`endDate`** (`Date | number` - optional): The end date or timestamp after which the job should no longer execute. _(_Only available when _interval format is a cron format)_
+ * **`skipDays`** (`string` - optional): A string defining days to skip; used for creating more complex schedules.
+ * **`skipImmediate`** (`boolean` - optional): If set to true, skips the immediate first execution of the job schedule.
+
+#### Returns
+
+* **`Promise`**: A promise that resolves with the created job or jobs. The promise will resolve after the jobs have been scheduled, or it will reject if there is an error during scheduling.
+
+
+
diff --git a/docs/creating-jobs/now.md b/docs/creating-jobs/now.md
new file mode 100644
index 0000000..698d892
--- /dev/null
+++ b/docs/creating-jobs/now.md
@@ -0,0 +1,35 @@
+# Now
+
+
+
+## `pulse.now(name, data?)`
+
+{% hint style="info" %}
+The `now` method schedules a job to be executed immediately. It creates a job instance and schedules it for the current time, allowing for rapid job processing.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+cconst pulse = new Pulse();
+
+// Schedule a job to run immediately to handle a high priority update
+pulse.now('urgentUpdate', { updateDetails: 'Fix critical security issue' })
+```
+
+
+
+#### Parameters
+
+* **`name`** (`string`): The name of the job to be scheduled. This name should correspond to a job type previously defined with the `define` method.
+* **`data`** (`T` - optional): Data to pass to the job for its execution. This can be any type of data that the job requires to perform its tasks.
+
+#### Returns
+
+* **`Promise`**: A promise that resolves with the created job instance. This job is scheduled to start immediately unless the job queue is currently full or other jobs are already scheduled for the same time.
+
+\
+
+
+
+
diff --git a/docs/creating-jobs/schedule.md b/docs/creating-jobs/schedule.md
new file mode 100644
index 0000000..06611f5
--- /dev/null
+++ b/docs/creating-jobs/schedule.md
@@ -0,0 +1,43 @@
+# Schedule
+
+
+
+## `pulse.schedule(when, names, data?)`
+
+{% hint style="info" %}
+The `schedule` method allows you to set a specific time for a job or multiple jobs to be executed. This is useful for tasks that must occur at precise times rather than at regular intervals.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+cconst pulse = new Pulse();
+
+// Schedule a single job to run next Monday at 9 AM
+const nextMonday = new Date();
+nextMonday.setDate(nextMonday.getDate() + ((1 + 7 - nextMonday.getDay()) % 7 || 7));
+nextMonday.setHours(9, 0, 0, 0);
+
+pulse.schedule(nextMonday, 'weeklyMeetingReminder', { meetingId: 456 });
+
+pulse.schedule('tomorrow at noon', [
+ 'printAnalyticsReport',
+ 'sendNotifications',
+ 'updateUserRecords'
+]);
+```
+
+
+
+#### Parameters
+
+* **`when`** (`string | Date`): The specific time when the job should be executed. This can be a string representing a date or a `Date` object.
+* **`names`** (`string | string[]`): The name or array of names of the job(s) to be scheduled. Each name corresponds to a job type previously defined with the `define` method.
+* **`data`** (`T` - optional): Data to pass to the job when it runs. This could be any type of data required by the job for its execution.
+
+#### Returns
+
+* **`Promise`**: A promise that resolves with the created job or jobs. The promise will resolve after the job has been scheduled, or it will reject if there is an error during scheduling.
+
+
+
diff --git a/docs/defining-job-processors.md b/docs/defining-job-processors.md
new file mode 100644
index 0000000..edcba2d
--- /dev/null
+++ b/docs/defining-job-processors.md
@@ -0,0 +1,58 @@
+# Defining Job Processors
+
+
+
+## `pulse.define(name, processor, options)`
+
+{% hint style="info" %}
+Before you can use a job, you must define its processing behavior.
+
+\
+The `define` method is used to configure how specific types of jobs should be handled by the `Pulse` instance. It allows you to specify a job's processing function and its operational parameters, such as concurrency limits, lock behaviors, and execution priority.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Define a job type for sending emails
+pulse.define('sendEmail', async (job, done) => {
+ try {
+ await sendEmail(job.data);
+ done(); // Mark the job as completed
+ } catch (error) {
+ console.error('Failed to send email:', error);
+ }
+}, {
+ concurrency: 5,
+ lockLimit: 2,
+ priority: 'high',
+ lockLifetime: 300000, // 5 minutes
+ shouldSaveResult: true
+});
+
+```
+
+
+
+#### Parameters
+
+* **`name`** (`string`): The unique name for the job type. This name is used to refer to and manage jobs of this type throughout their lifecycle.
+* **`processor`** (`Processor`): The function that contains the logic to be executed when a job of this type is processed. The function receives a `Job` object and an optional `done` callback that should be called when the job processing completes.
+* **`options`** (`DefineOptions` - optional): Configuration options for the job, which include:
+ * **`concurrency`** (`number`): Maximum number of instances of the job that can run simultaneously. Defaults to `Pulse`'s `_defaultConcurrency`.
+ * **`lockLimit`** (`number`): Maximum number of instances of the job that can be locked at once. Defaults to `Pulse`'s `_defaultLockLimit`.
+ * **`lockLifetime`** (`number`): Duration in milliseconds that the job remains locked (i.e., unavailable for re-processing) unless explicitly unlocked sooner. Defaults to `Pulse`'s `_defaultLockLifetime`.
+ * **`priority`** (`lowest|low|normal|high|highest|number`): The priority level of the job. Jobs with higher priority are processed first. Defaults to `normal`.
+ * **`shouldSaveResult`** (`boolean`): Indicates whether the result of the job processing should be saved. Defaults to `false`.
+
+\
+
+
+#### Returns
+
+* **`void`**: This method does not return a value.
+
+
+
diff --git a/docs/setup-and-config/README.md b/docs/setup-and-config/README.md
new file mode 100644
index 0000000..fb80292
--- /dev/null
+++ b/docs/setup-and-config/README.md
@@ -0,0 +1,3 @@
+# Setup & Config
+
+##
diff --git a/docs/setup-and-config/config/README.md b/docs/setup-and-config/config/README.md
new file mode 100644
index 0000000..4aabf8d
--- /dev/null
+++ b/docs/setup-and-config/config/README.md
@@ -0,0 +1,3 @@
+# Config
+
+pulse.name(name)
diff --git a/docs/setup-and-config/config/defaultconcurrency.md b/docs/setup-and-config/config/defaultconcurrency.md
new file mode 100644
index 0000000..29c571b
--- /dev/null
+++ b/docs/setup-and-config/config/defaultconcurrency.md
@@ -0,0 +1,31 @@
+# DefaultConcurrency
+
+
+
+## `pulse.defaultConcurrency(concurrency)`
+
+{% hint style="info" %}
+The `defaultConcurrency` method sets the default number of jobs that can be processed concurrently by a `Pulse` instance. This setting is crucial for controlling how many jobs are run at the same time, affecting resource utilization and job throughput.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set the default concurrency for job processing to 3
+pulse.defaultConcurrency(3);
+```
+
+
+
+#### Parameters
+
+* **`concurrency`** (`number`): The default number of concurrent jobs that the system should process. This value sets a baseline for job processing unless explicitly overridden by specific jobs.
+
+#### Returns
+
+* **`Pulse`**: Returns the `Pulse` instance, allowing for chaining of additional method calls.
+
+
+
diff --git a/docs/setup-and-config/config/defaultlocklifetime.md b/docs/setup-and-config/config/defaultlocklifetime.md
new file mode 100644
index 0000000..d7f6def
--- /dev/null
+++ b/docs/setup-and-config/config/defaultlocklifetime.md
@@ -0,0 +1,32 @@
+# DefaultLockLifetime
+
+
+
+## `pulse.defaultLockLifetime(ms)`
+
+{% hint style="info" %}
+The `defaultLockLifetime` method sets the default duration (in milliseconds) that a job can remain locked during processing before it is automatically released. This setting helps manage job recovery and ensures that jobs do not remain locked indefinitely if an error occurs or if the job processing is not completed as expected.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set the default lock lifetime to 5 minutes (300000 ms)
+pulse.defaultLockLifetime(300000);
+```
+
+
+
+#### Parameters
+
+* **`ms`** (`number`): The duration in milliseconds for how long jobs should be locked by default.
+ * default: 600,000ms
+
+#### Returns
+
+* **`Pulse`**: Returns the instance of the `Pulse` class, allowing for method chaining.
+
+
+
diff --git a/docs/setup-and-config/config/defaultlocklimit.md b/docs/setup-and-config/config/defaultlocklimit.md
new file mode 100644
index 0000000..f4054bb
--- /dev/null
+++ b/docs/setup-and-config/config/defaultlocklimit.md
@@ -0,0 +1,31 @@
+# DefaultLockLimit
+
+
+
+## `pulse.defaultLockLimit(times)`
+
+{% hint style="info" %}
+The `defaultLockLimit` method sets the default number of times jobs of any given type can be locked concurrently. This setting helps to manage the concurrency of job processing more finely by limiting how many instances of the same job type can be prepared for execution at the same time.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set the default concurrency for job processing to 3
+pulse.defaultLockLimit(2);
+```
+
+
+
+#### Parameters
+
+* **`times`** (`number`): The maximum number of times jobs of a specific type can be locked concurrently.
+
+#### Returns
+
+* **`Pulse`**: Returns the instance of the `Pulse` class, allowing for method chaining.
+
+
+
diff --git a/docs/setup-and-config/config/locklimit.md b/docs/setup-and-config/config/locklimit.md
new file mode 100644
index 0000000..8005674
--- /dev/null
+++ b/docs/setup-and-config/config/locklimit.md
@@ -0,0 +1,31 @@
+# LockLimit
+
+
+
+## `pulse.lockLimit(limit)`
+
+{% hint style="info" %}
+The `lockLimit` method sets the maximum number of jobs that can be locked by the `Pulse` instance at any one time. This is a global setting affecting all job processing, helping to control job concurrency and prevent overload.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set a global lock limit to prevent too many jobs from being locked at the same time
+pulse.lockLimit(5);
+```
+
+
+
+#### Parameters
+
+* **`limit`** (`number`): The maximum number of jobs that can be locked simultaneously across the system.
+
+#### Returns
+
+* **`Pulse`**: Returns the `Pulse` instance, enabling method chaining.
+
+
+
diff --git a/docs/setup-and-config/config/maxconcurrency.md b/docs/setup-and-config/config/maxconcurrency.md
new file mode 100644
index 0000000..0d0b825
--- /dev/null
+++ b/docs/setup-and-config/config/maxconcurrency.md
@@ -0,0 +1,31 @@
+# MaxConcurrency
+
+
+
+## `pulse.maxConcurrency(concurrency)`
+
+{% hint style="info" %}
+The `maxConcurrency` method sets the maximum number of jobs that can be processed concurrently across the entire `Pulse` instance, regardless of job type. This global setting is crucial for controlling overall system load and ensuring that job processing does not overwhelm system resources.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set the default concurrency for job processing to 3
+pulse.maxConcurrency(10);
+```
+
+
+
+#### Parameters
+
+* **`concurrency`** (`number`): The maximum number of concurrent jobs allowed. This setting applies to all job types handled by the `Pulse` instance.
+
+#### Returns
+
+* **`Pulse`**: Returns the instance of the `Pulse` class, enabling method chaining.
+
+
+
diff --git a/docs/setup-and-config/config/name.md b/docs/setup-and-config/config/name.md
new file mode 100644
index 0000000..fe4438f
--- /dev/null
+++ b/docs/setup-and-config/config/name.md
@@ -0,0 +1,26 @@
+# Name
+
+
+
+## `pulse.name(name)`
+
+{% hint style="info" %}
+The `name` method of the `Pulse` class allows setting or updating the name of the job queue. This name can be used for identification and management purposes within applications that may handle multiple queues.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+pulse.name('emailProcessingQueue');
+```
+
+#### Parameters
+
+* **`name`** (`string`): The name to assign to the Pulse instance's job queue.
+
+#### Returns
+
+* **`Pulse`**: Returns the instance of the `Pulse` class, allowing for method chaining.
+
+####
diff --git a/docs/setup-and-config/config/processevery.md b/docs/setup-and-config/config/processevery.md
new file mode 100644
index 0000000..e706dda
--- /dev/null
+++ b/docs/setup-and-config/config/processevery.md
@@ -0,0 +1,29 @@
+# ProcessEvery
+
+
+
+## `pulse.processEvery(interval)`
+
+{% hint style="info" %}
+The `name` method of the `Pulse` class allows setting or updating the name of the job queue. This name can be used for identification and management purposes within applications that may handle multiple queues.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Configure the job processing interval to every 10 minutes
+pulse.processEvery('10 minutes');
+```
+
+
+
+#### Parameters
+
+* **`interval`** (`string`): The interval at which to process jobs, expressed in a human-readable format, such as '5 minutes', '1 hour', etc.
+
+#### Returns
+
+* **`Pulse`**: Returns the instance of the `Pulse` class, facilitating method chaining.
+
diff --git a/docs/setup-and-config/config/sort.md b/docs/setup-and-config/config/sort.md
new file mode 100644
index 0000000..c2d4f62
--- /dev/null
+++ b/docs/setup-and-config/config/sort.md
@@ -0,0 +1,31 @@
+# Sort
+
+
+
+## `pulse.sort(query)`
+
+{% hint style="info" %}
+The `sort` method customizes the sorting order of jobs when querying the MongoDB database. This order can significantly affect the efficiency and priority with which jobs are processed.
+{% endhint %}
+
+### Example Usage
+
+```typescript
+const pulse = new Pulse();
+
+// Set a custom sort order for job processing
+pulse.sort({ createdAt: -1 });
+```
+
+
+
+#### Parameters
+
+* **`query`** (`object`): A MongoDB sort query object that specifies how to order the jobs. For example, `{ nextRunAt: 1, priority: -1 }` will sort jobs primarily by their next scheduled run time in ascending order and by priority in descending order if there are ties.
+
+#### Returns
+
+* **`Pulse`**: Returns the instance of the `Pulse` class, enabling method chaining.
+
+
+
diff --git a/docs/setup-and-config/connection.md b/docs/setup-and-config/connection.md
new file mode 100644
index 0000000..8ad2666
--- /dev/null
+++ b/docs/setup-and-config/connection.md
@@ -0,0 +1,55 @@
+# Connection
+
+The MongoDB connection can be configured through the `PulseConfig` object, which supports either direct client reuse or new connection parameters.
+
+
+
+#### Example Usage
+
+```typescript
+const pulseConfig = {
+ processEvery: '1 minute',
+ maxConcurrency: 10,
+ db: {
+ address: 'mongodb://localhost:27017/myApp',
+ collection: 'jobQueue'
+ }
+};
+
+
+
+const pulse = new Pulse(pulseConfig, (error, collection) => {
+ if (error) {
+ console.error('Connection error:', error);
+ } else {
+ console.log('Connected to MongoDB collection:', collection.collectionName);
+ }
+});
+```
+
+
+
+
+
+### `new Pulse(config?, cb?)`
+
+#### Parameters
+
+* **`config`**
+ * **`name`** (`string` - optional): Specifies the name of the job queue. This can be used for identifying and managing different queues within the same application.
+ * **`processEvery`** (`string` - optional): Defines how often the job processor should poll for new jobs to process. The string should be a human-readable interval, such as `'5 minutes'`, `'1 hour'`. Defaults to `'5 seconds'` if not specified.
+ * **`maxConcurrency`** (`number` - optional): The maximum number of jobs that can be processed concurrently. Helps in controlling resource utilization.
+ * **`defaultConcurrency`** (`number` - optional): The default concurrency for jobs that do not specify their own concurrency setting.
+ * **`lockLimit`** (`number` - optional): Maximum number of jobs that can be locked at the same time. This prevents a single worker from locking too many jobs.
+ * **`defaultLockLimit`** (`number` - optional): Default limit for the number of jobs each worker can lock simultaneously.
+ * **`defaultLockLifetime`** (`number` - optional): Duration in milliseconds for how long a job can be locked before it is automatically unlocked. Useful for handling job crashes or stalls. Defaults to 600000 ms (10 minutes).
+ * **`sort`** (`any` - optional): Determines the order in which jobs are selected and locked from the database. For example, `{ nextRunAt: 1, priority: -1 }` sorts by `nextRunAt` ascending and `priority` descending.
+ * **`mongo`** (`MongoDb` - optional): An existing MongoDB client that can be reused instead of creating a new connection.
+ * **`db`** (`object` - optional): Configuration for the MongoDB connection if not using an existing `MongoDb` client. Includes:
+ * **`address`** (`string`): The MongoDB connection URI.
+ * **`collection`** (`string` - optional): Specifies the MongoDB collection to use. Defaults to `pulseJobs`.
+ * **`options`** (`MongoClientOptions` - optional): MongoDB client options.
+ * **`disableAutoIndex`** (`boolean` - optional): If set to `true`, automatic indexing of job fields by the `Pulse` system is disabled. Useful for performance tuning in production environments.
+
+
+
diff --git a/quick-start.md b/quick-start.md
new file mode 100644
index 0000000..f3942d5
--- /dev/null
+++ b/quick-start.md
@@ -0,0 +1,96 @@
+# Quick Start
+
+### Installation
+
+```bash
+npm i @pulsecron/pulse
+```
+
+
+
+### Example
+
+```typescript
+import Pulse from '@pulsecron/pulse';
+
+const mongoConnectionString = 'mongodb://localhost:27017/pulse';
+
+const pulse = new Pulse({ db: { address: mongoConnectionString } });
+
+// Or override the default collection name:
+// const pulse = new Pulse({db: {address: mongoConnectionString, collection: 'jobCollectionName'}});
+
+// or pass additional connection options:
+// const pulse = new Pulse({db: {address: mongoConnectionString, collection: 'jobCollectionName', options: {ssl: true}}});
+
+// or pass in an existing mongodb-native MongoClient instance
+// const pulse = new Pulse({mongo: myMongoClient});
+
+/**
+ * Example of defining a job
+ */
+pulse.define('delete old users', async (job) => {
+ console.log('Deleting old users...');
+ return;
+});
+
+/**
+ * Example of repeating a job
+ */
+(async function () {
+ // IIFE to give access to async/await
+ await pulse.start();
+
+ await pulse.every('3 minutes', 'delete old users');
+
+ // Alternatively, you could also do:
+ await pulse.every('*/3 * * * *', 'delete old users');
+})();
+
+/**
+ * Example of defining a job with options
+ */
+pulse.define(
+ 'send email report',
+ async (job) => {
+ const { to } = job.attrs.data;
+
+ console.log(`Sending email report to ${to}`);
+ },
+ { lockLifetime: 5 * 1000, priority: 'high', concurrency: 10 }
+);
+
+/**
+ * Example of scheduling a job
+ */
+(async function () {
+ await pulse.start();
+ await pulse.schedule('in 20 minutes', 'send email report', { to: 'admin@example.com' });
+})();
+
+/**
+ * Example of repeating a job
+ */
+(async function () {
+ const weeklyReport = pulse.create('send email report', { to: 'example@example.com' });
+ await pulse.start();
+ await weeklyReport.repeatEvery('1 week').save();
+})();
+
+/**
+ * Check job start and completion/failure
+ */
+pulse.on('start', (job) => {
+ console.log(time(), `Job <${job.attrs.name}> starting`);
+});
+pulse.on('success', (job) => {
+ console.log(time(), `Job <${job.attrs.name}> succeeded`);
+});
+pulse.on('fail', (error, job) => {
+ console.log(time(), `Job <${job.attrs.name}> failed:`, error);
+});
+
+function time() {
+ return new Date().toTimeString().split(' ')[0];
+}
+```
diff --git a/why-pulse.md b/why-pulse.md
new file mode 100644
index 0000000..a655197
--- /dev/null
+++ b/why-pulse.md
@@ -0,0 +1,28 @@
+# Why Pulse?
+
+
+
+## **Continuation of Agenda**:
+
+* Pulse is developed as a continuation of the popular Agenda project, which is no longer actively maintained.
+* Recognizing the gap left in the Node.js ecosystem, Pulse aims to provide ongoing support and enhancements for job scheduling needs.
+
+## **Advanced Functionalities**:
+
+* Introduces new features that tackle complex scheduling challenges more effectively than its predecessor.
+* Designed with modern requirements in mind, ensuring that it remains a relevant tool for developers.
+
+## **Improved Scalability**:
+
+* Built to handle large-scale job processing more efficiently, accommodating growing application demands.
+* Optimized for performance, making it suitable for high-load environments.
+
+## **Integration and Flexibility**:
+
+* Offers seamless integration with existing Node.js applications and MongoDB, reducing the learning curve and implementation effort.
+* Supports a variety of job types including cron, one-time, and recurring jobs with enhanced control over scheduling.
+
+## **Community and Support**:
+
+* Backed by a community of developers who are committed to maintaining and expanding its capabilities.
+* Provides extensive documentation and examples to help users get started and maximize their use of the tool.