Zero-Dependency Task Scheduling in ODAC.JS
The modern Node.js ecosystem has a strange obsession with operational complexity. When an engineering team needs to clear expired sessions from a database once a night, the default instinct is to reach for a heavy hammer. Developers will spin up a Redis cluster, install complex queue libraries, configure a separate worker process, and monitor the entire brittle contraption just to run two lines of SQL at 3 AM.
This is the exact opposite of the "Zero Dependency, Maximum Power" philosophy we champion in ODAC.JS.
Task scheduling is a fundamental requirement of any enterprise application. Relying on external dependencies for this basic capability adds latency, introduces new failure vectors, and destroys the simplicity of a single-binary deployment. That is why ODAC.JS features a built-in precision cron scheduler wired directly into the routing engine.
The Architecture of Internal Scheduling
The built-in cron system evaluates the state of your background tasks every minute without relying on setInterval hacks that drift over time. Instead of requiring external worker files, you define jobs right alongside your standard HTTP routes.
Our engine handles the execution lifecycle gracefully. If a job fails and throws an error, the framework catches it, prevents the event loop from crashing, and allows the rest of the system to continue operating without interruption. You get enterprise-grade resilience straight out of the box.
Show Me The Code: The Quick Start
The fastest way to get started is by defining an inline asynchronous function. This is perfect for simple health checks, metrics logging, or lightweight database cleanup tasks.
Odac.Route.cron(async () => {
const stats = await Odac.DB.table('orders').count();
console.log('Current orders:', stats);
}).everyHour(1);
You pass a closure directly to Odac.Route.cron(), and then use our fluent scheduling API to dictate the interval. Here is a breakdown of the core API:
.everyHour(n)/.everyDay(n): Simple periodic execution..hour(n)/.minute(n): Precision targeting for specific values..raw(expression): Direct access to standard UNIX cron expressions.
It is clean, readable, and requires zero setup.
The Enterprise Pattern: Controller-Based Cron
Inline functions are excellent for prototypes, but large-scale applications require a stricter separation of concerns. Just as ODAC.JS maps HTTP routes to dedicated controllers, you can map scheduled tasks to isolated files inside your controller/cron/ directory.
First, define the schedule in your routing file:
// route/cron.js
Odac.Route.cron('cleanup').at('03:00');
Then, write the business logic in the matching controller file. The framework automatically injects the global Odac instance, giving you immediate access to your database connections, services, and configuration.
// controller/cron/cleanup.js
module.exports = async (Odac) => {
console.log('Running nightly cleanup...');
await Odac.DB.table('logs').where('created_at', '<', 'NOW() - INTERVAL 30 DAY').delete();
};
This pattern ensures your scheduled tasks remain modular and perfectly aligned with the rest of your MVC architecture.
Escaping the Wildcard Trap
Traditional cron syntax is powerful but notoriously unforgiving. A common mistake when designing scheduled tasks is defining an hour condition while forgetting the minute condition. In many systems, setting the hour to 14 without pinning the minute means the task will execute sixty times (every single minute between 14:00 and 14:59).
ODAC.JS solves this DX nightmare with the .at() shorthand method.
// This safely sets both the hour and the minute condition simultaneously.
Odac.Route.cron('daily-report').at('14:30');
For teams migrating from legacy systems, ODAC.JS still supports raw UNIX cron expressions through the .raw() method.
// Run every 15 minutes using standard syntax
Odac.Route.cron('sync').raw('*/15 * * * *');
Ditch the Boilerplate
You do not need an armada of microservices to build scalable software. By pulling task scheduling into the framework layer, ODAC.JS eliminates a massive source of boilerplate and operational overhead. Your background tasks, database queries, and HTTP endpoints all live under one roof, sharing the same memory space and the same optimized connection pools.
Drop the heavy dependencies. Reclaim your architecture. Build faster with ODAC.JS.
++ b/skeleton/main.html
