@luisrodrigues/nestjs-scheduler-dashboard 0.0.2 → 0.0.4

package/README.md

@@ -2,19 +2,20 @@
 
 A plug-and-play dashboard for [`@nestjs/schedule`](https://docs.nestjs.com/techniques/task-scheduling). Visualize cron job executions, track history and metrics, trigger jobs manually, and stop running executions — all from an embedded UI with zero external dependencies.
 
+The dashboard runs on its own dedicated port (default **3636**), completely isolated from your main application.
+
 ---
 
 ## Features
 
-- Embedded UI served directly from your NestJS app (no separate frontend server)
 - Execution history per job with status, duration, and error details
 - Persistent metrics: total runs, failed runs, average duration — independent of history retention
 - Manual job triggering and execution stop from the UI
-- Concurrency control: limit how many jobs run simultaneously with a queue
-- No-overlap mode: skip or queue a job if it is already running
+- Concurrency control: limit how many jobs run simultaneously, with automatic queuing
+- No-overlap mode: skip a job if it is already running
 - Optional HTTP Basic Auth to protect the dashboard
 - Light / dark mode
-- Standalone server mode (separate port) or embedded in your existing app
+- Zero external runtime dependencies — served from a single self-contained HTML file
 
 ---
 
@@ -29,14 +30,14 @@ pnpm add @luisrodrigues/nestjs-scheduler-dashboard
 **Peer dependencies** (install if not already present):
 
 ```bash
-npm install @nestjs/common @nestjs/schedule
+npm install @nestjs/common @nestjs/core @nestjs/schedule
 ```
 
 ---
 
 ## Quick start
 
-### 1. Initialize the dashboard in `main.ts`
+### 1. Call `setupSchedulerDash` in `main.ts`
 
 ```ts
 import { NestFactory } from '@nestjs/core';
@@ -46,16 +47,17 @@ import { setupSchedulerDash } from '@luisrodrigues/nestjs-scheduler-dashboard';
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
 
-  await setupSchedulerDash(app);
+  // Must be called BEFORE app.listen() so storage is ready before cron jobs start
+  await setupSchedulerDash(app, { port: 3636 });
 
   await app.listen(3000);
+  console.log('App running at   http://localhost:3000');
+  console.log('Dashboard at     http://localhost:3636');
 }
 
 bootstrap();
 ```
 
-The dashboard is now available at `http://localhost:3000/_jobs`.
-
 ### 2. Decorate your jobs
 
 Replace `@Cron` with `@TrackJob` — it accepts the same arguments:
@@ -74,24 +76,25 @@ export class ReportJob {
 }
 ```
 
+That's it. Open `http://localhost:3636` to see the dashboard.
+
 ---
 
 ## Configuration
 
-`setupSchedulerDash(app, options?)` accepts the following options:
+`setupSchedulerDash(app, options?)` accepts:
 
 | Option | Type | Default | Description |
 |---|---|---|---|
+| `port` | `number` | `3636` | Port for the dashboard HTTP server |
 | `storage` | `Storage` | `new MemoryStorage()` | Storage backend for execution history and metrics |
-| `basePath` | `string` | `'_jobs'` | URL path where the dashboard is mounted |
-| `port` | `number` | — | When set, serves the dashboard on a separate HTTP server instead of mounting on the main app |
-| `maxConcurrent` | `number` | — | Maximum number of `@TrackJob` jobs that can run at the same time. Excess jobs are queued |
+| `maxConcurrent` | `number` | — | Maximum number of jobs that can run simultaneously. Excess jobs are queued |
 | `noOverlap` | `boolean` | `false` | Globally prevent a job from starting if it is already running |
-| `auth` | `{ username, password }` | — | Protect all dashboard routes with HTTP Basic Auth |
+| `auth` | `{ username, password }` | — | Protect the dashboard with HTTP Basic Auth |
 
 ### `storage`
 
-The storage backend persists execution history and metrics. The built-in `MemoryStorage` keeps everything in-process.
+The default `MemoryStorage` keeps everything in-process. You can limit how many history entries are kept per job:
 
 ```ts
 import { MemoryStorage } from '@luisrodrigues/nestjs-scheduler-dashboard';
@@ -103,7 +106,7 @@ await setupSchedulerDash(app, {
 });
 ```
 
-> **Metrics are independent of `historyRetention`.** Even if old history entries are removed, the counters for total runs, failed runs, and average duration keep accumulating.
+> **Metrics are independent of `historyRetention`.** Even after old history entries are trimmed, the counters for total runs, failed runs, and average duration keep accumulating.
 
 To use a custom storage backend, extend the abstract `Storage` class:
 
@@ -124,42 +127,19 @@ export class RedisStorage extends Storage {
 }
 ```
 
-### `basePath`
-
-Changes the URL where the dashboard is served. Must contain only alphanumeric characters, hyphens, underscores, or slashes.
-
-```ts
-await setupSchedulerDash(app, {
-  basePath: 'admin/scheduler',
-  // dashboard → http://localhost:3000/admin/scheduler
-});
-```
-
-### `port`
-
-Serve the dashboard on a completely separate HTTP server, isolated from your main application.
-
-```ts
-await setupSchedulerDash(app, {
-  port: 3001,
-  // dashboard → http://localhost:3001/_jobs
-  // main app  → http://localhost:3000
-});
-```
-
 ### `maxConcurrent`
 
-Limits the total number of `@TrackJob` jobs that can execute simultaneously across your entire application. Jobs that cannot start immediately are saved to storage with status `"queued"` and run in FIFO order as slots free up.
+Limits how many `@TrackJob` jobs can run simultaneously across the entire application. Jobs that exceed the limit are saved to storage with status `"queued"` and run in FIFO order as slots free up.
 
 ```ts
 await setupSchedulerDash(app, {
-  maxConcurrent: 5, // at most 5 jobs running at the same time
+  maxConcurrent: 5,
 });
 ```
 
 ### `noOverlap`
 
-Prevents a job from firing again if the same job is still running. Applies globally to all `@TrackJob`-decorated methods.
+Prevents a job from firing again if it is still running. Applies globally to all `@TrackJob` methods.
 
 ```ts
 await setupSchedulerDash(app, {
@@ -167,7 +147,7 @@ await setupSchedulerDash(app, {
 });
 ```
 
-Can also be set per job via the decorator, which takes precedence over the global setting:
+Can also be overridden per job in the decorator:
 
 ```ts
 @TrackJob(CronExpression.EVERY_MINUTE, { name: 'sync', noOverlap: true })
@@ -176,13 +156,11 @@ async sync() { /* ... */ }
 
 ### `auth`
 
-Protect the dashboard with HTTP Basic Auth.
-
 ```ts
 await setupSchedulerDash(app, {
   auth: {
-    username: 'admin',
-    password: 'supersecret',
+    username: process.env.DASH_USER ?? 'admin',
+    password: process.env.DASH_PASS ?? 'secret',
   },
 });
 ```
@@ -191,7 +169,7 @@ await setupSchedulerDash(app, {
 
 ## `@TrackJob` decorator
 
-`@TrackJob` is a drop-in replacement for `@Cron` from `@nestjs/schedule`. It accepts all the same options plus `noOverlap`.
+Drop-in replacement for `@Cron`. Accepts all the same options plus `noOverlap`.
 
 ```ts
 @TrackJob(cronTime, options?)
@@ -200,9 +178,9 @@ await setupSchedulerDash(app, {
 | Argument | Type | Description |
 |---|---|---|
 | `cronTime` | `string \| CronExpression` | Cron expression or `CronExpression` enum value |
-| `options.name` | `string` | Human-readable job name shown in the dashboard. Defaults to the method name |
-| `options.noOverlap` | `boolean` | Skip this job if it is already running. Overrides the global `noOverlap` setting |
-| `options.*` | — | All other [`CronOptions`](https://docs.nestjs.com/techniques/task-scheduling) from `@nestjs/schedule` are passed through |
+| `options.name` | `string` | Job name shown in the dashboard. Defaults to `ClassName.methodName` |
+| `options.noOverlap` | `boolean` | Skip this job if it is already running. Overrides the global setting |
+| `options.*` | — | All other [`CronOptions`](https://docs.nestjs.com/techniques/task-scheduling) are passed through |
 
 ```ts
 @TrackJob('0 */6 * * *', {
@@ -217,22 +195,31 @@ async cleanup() {
 
 ---
 
-## Full configuration example
+## API
+
+The dashboard exposes a small REST API on the same port as the UI.
+
+| Method | Path | Description |
+|---|---|---|
+| `GET` | `/api` | Returns all jobs with history and metrics |
+| `POST` | `/api/:name/trigger` | Manually trigger a cron job by name |
+| `POST` | `/api/executions/:id/stop` | Stop a running or queued execution by ID |
+
+---
+
+## Full example
 
 ```ts
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
-import {
-  setupSchedulerDash,
-  MemoryStorage,
-} from '@luisrodrigues/nestjs-scheduler-dashboard';
+import { setupSchedulerDash, MemoryStorage } from '@luisrodrigues/nestjs-scheduler-dashboard';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
 
   await setupSchedulerDash(app, {
+    port: 3636,
     storage: new MemoryStorage({ historyRetention: 100 }),
-    basePath: 'scheduler',
     maxConcurrent: 3,
     noOverlap: true,
     auth: {
@@ -249,18 +236,6 @@ bootstrap();
 
 ---
 
-## API
-
-The dashboard exposes a small REST API used by the UI. You can also call it directly.
-
-| Method | Path | Description |
-|---|---|---|
-| `GET` | `/{basePath}/api` | Returns all jobs with history and metrics |
-| `POST` | `/{basePath}/api/:name/trigger` | Manually trigger a cron job by name |
-| `POST` | `/{basePath}/api/executions/:id/stop` | Stop a running or queued execution by ID |
-
----
-
 ## License
 
 MIT

package/dist/auth.d.ts

@@ -2,4 +2,4 @@ import { IncomingMessage, ServerResponse } from 'http';
 import { SchedulerDashAuth } from './scheduler-dash.options';
 export declare function checkBasicAuth(req: IncomingMessage, auth: SchedulerDashAuth): boolean;
 export declare function rejectUnauthorized(res: ServerResponse): void;
-export declare function createAuthGuard(auth: SchedulerDashAuth | undefined): (req: any, res: any, next: any) => any;
+export declare function createAuthGuard(auth: SchedulerDashAuth | undefined): (_req: any, _res: any, next: any) => any;

package/dist/auth.js

@@ -5,27 +5,22 @@ exports.rejectUnauthorized = rejectUnauthorized;
 exports.createAuthGuard = createAuthGuard;
 function checkBasicAuth(req, auth) {
     const header = req.headers['authorization'] ?? '';
-    if (!header.startsWith('Basic '))
+    const [scheme, encoded] = header.split(' ');
+    if (scheme !== 'Basic' || !encoded)
         return false;
-    const decoded = Buffer.from(header.slice(6), 'base64').toString('utf-8');
-    const [user, ...rest] = decoded.split(':');
-    return user === auth.username && rest.join(':') === auth.password;
+    const [username, password] = Buffer.from(encoded, 'base64').toString('utf8').split(':');
+    return username === auth.username && password === auth.password;
 }
 function rejectUnauthorized(res) {
-    res.writeHead(401, {
-        'WWW-Authenticate': 'Basic realm="Scheduler Dashboard"',
-        'Content-Type': 'text/plain',
-    });
+    res.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Scheduler Dashboard"' });
     res.end('Unauthorized');
 }
 function createAuthGuard(auth) {
+    if (!auth)
+        return (_req, _res, next) => next();
     return (req, res, next) => {
-        if (!auth)
-            return next();
-        if (!checkBasicAuth(req, auth)) {
-            res.setHeader('WWW-Authenticate', 'Basic realm="Scheduler Dashboard"');
-            return res.status(401).send('Unauthorized');
-        }
+        if (!checkBasicAuth(req, auth))
+            return rejectUnauthorized(res);
         next();
     };
 }

package/dist/{jobs.controller.d.ts → dashboard.controller.d.ts}

@@ -1,9 +1,7 @@
 import { JobsService } from './jobs.service';
-export declare class JobsController {
+export declare class DashboardController {
     private readonly jobsService;
     constructor(jobsService: JobsService);
-    dashboard(): string;
-    dashboardDetail(): string;
     getJobs(): {
         cron: {
             name: string;
@@ -11,6 +9,7 @@ export declare class JobsController {
             running: boolean;
             nextRun: string;
             history: import(".").JobExecution[];
+            metrics: import(".").JobMetrics;
         }[];
         intervals: {
             name: string;
@@ -22,4 +21,7 @@ export declare class JobsController {
     triggerJob(name: string): {
         triggered: string;
     };
+    stopExecution(id: string): {
+        stopped: string;
+    };
 }

package/dist/{jobs.controller.js → dashboard.controller.js}

@@ -12,61 +12,51 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsController = void 0;
+exports.DashboardController = void 0;
 const common_1 = require("@nestjs/common");
-const basic_auth_guard_1 = require("./basic-auth.guard");
 const jobs_service_1 = require("./jobs.service");
-const dashboard_1 = require("./ui/dashboard");
-let JobsController = class JobsController {
+let DashboardController = class DashboardController {
     constructor(jobsService) {
         this.jobsService = jobsService;
     }
-    dashboard() {
-        return dashboard_1.dashboardHtml;
-    }
-    dashboardDetail() {
-        return dashboard_1.dashboardHtml;
-    }
     getJobs() {
         return this.jobsService.getJobs();
     }
     triggerJob(name) {
         const ok = this.jobsService.triggerJob(name);
         if (!ok)
-            throw new common_1.NotFoundException(`Job "${name}" not found`);
+            throw new common_1.HttpException(`Job "${name}" not found`, common_1.HttpStatus.NOT_FOUND);
         return { triggered: name };
     }
+    stopExecution(id) {
+        const ok = this.jobsService.stopExecution(id);
+        if (!ok)
+            throw new common_1.HttpException(`Execution "${id}" not found or already finished`, common_1.HttpStatus.NOT_FOUND);
+        return { stopped: id };
+    }
 };
-exports.JobsController = JobsController;
+exports.DashboardController = DashboardController;
 __decorate([
     (0, common_1.Get)(),
-    (0, common_1.Header)('Content-Type', 'text/html; charset=utf-8'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], JobsController.prototype, "dashboard", null);
-__decorate([
-    (0, common_1.Get)('jobs/:name'),
-    (0, common_1.Header)('Content-Type', 'text/html; charset=utf-8'),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
-], JobsController.prototype, "dashboardDetail", null);
+], DashboardController.prototype, "getJobs", null);
 __decorate([
-    (0, common_1.Get)('api'),
+    (0, common_1.Post)(':name/trigger'),
+    __param(0, (0, common_1.Param)('name')),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
+    __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
-], JobsController.prototype, "getJobs", null);
+], DashboardController.prototype, "triggerJob", null);
 __decorate([
-    (0, common_1.Post)('api/:name/trigger'),
-    __param(0, (0, common_1.Param)('name')),
+    (0, common_1.Post)('executions/:id/stop'),
+    __param(0, (0, common_1.Param)('id')),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
-], JobsController.prototype, "triggerJob", null);
-exports.JobsController = JobsController = __decorate([
-    (0, common_1.Controller)(),
-    (0, common_1.UseGuards)(basic_auth_guard_1.BasicAuthGuard),
+], DashboardController.prototype, "stopExecution", null);
+exports.DashboardController = DashboardController = __decorate([
+    (0, common_1.Controller)('api'),
     __metadata("design:paramtypes", [jobs_service_1.JobsService])
-], JobsController);
+], DashboardController);

package/dist/{jobs-tracker.service.d.ts → dashboard.module.d.ts}

@@ -1,9 +1,10 @@
-import { SchedulerDashOptions } from './scheduler-dash.options';
+import { DynamicModule, OnModuleInit } from '@nestjs/common';
 import { Storage } from './storage/storage.abstract';
-export declare class JobsTrackerService {
+import { SchedulerDashOptions } from './scheduler-dash.options';
+export declare class DashboardModule implements OnModuleInit {
     private readonly storage;
     private readonly options;
-    private readonly logger;
     constructor(storage: Storage, options: SchedulerDashOptions);
     onModuleInit(): void;
+    static forRoot(options?: SchedulerDashOptions): DynamicModule;
 }

package/dist/{jobs-tracker.service.js → dashboard.module.js}

@@ -11,30 +11,40 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var DashboardModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsTrackerService = void 0;
+exports.DashboardModule = void 0;
 const common_1 = require("@nestjs/common");
-const scheduler_dash_options_1 = require("./scheduler-dash.options");
-const scheduler_dash_context_1 = require("./scheduler-dash.context");
 const storage_abstract_1 = require("./storage/storage.abstract");
-let JobsTrackerService = class JobsTrackerService {
+const memory_storage_1 = require("./storage/memory.storage");
+const scheduler_dash_context_1 = require("./scheduler-dash.context");
+const STORAGE_TOKEN = Symbol('DASHBOARD_STORAGE');
+const OPTIONS_TOKEN = Symbol('DASHBOARD_OPTIONS');
+let DashboardModule = DashboardModule_1 = class DashboardModule {
     constructor(storage, options) {
         this.storage = storage;
         this.options = options;
-        this.logger = new common_1.Logger('SchedulerDash');
     }
     onModuleInit() {
         scheduler_dash_context_1.SchedulerDashContext.storage = this.storage;
-        scheduler_dash_context_1.SchedulerDashContext.basePath = this.options.basePath ?? '_jobs';
-        const basePath = scheduler_dash_context_1.SchedulerDashContext.basePath;
-        this.logger.log(`Dashboard available at /${basePath}`);
-        this.logger.log(`API available at /${basePath}/api`);
+        scheduler_dash_context_1.SchedulerDashContext.noOverlap = this.options.noOverlap ?? false;
+        scheduler_dash_context_1.SchedulerDashContext.maxConcurrent = this.options.maxConcurrent;
+    }
+    static forRoot(options = {}) {
+        const storage = options.storage ?? new memory_storage_1.MemoryStorage({ historyRetention: 10 });
+        return {
+            module: DashboardModule_1,
+            providers: [
+                { provide: STORAGE_TOKEN, useValue: storage },
+                { provide: OPTIONS_TOKEN, useValue: options },
+            ],
+        };
     }
 };
-exports.JobsTrackerService = JobsTrackerService;
-exports.JobsTrackerService = JobsTrackerService = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(scheduler_dash_options_1.SCHEDULER_DASH_STORAGE)),
-    __param(1, (0, common_1.Inject)(scheduler_dash_options_1.SCHEDULER_DASH_OPTIONS)),
+exports.DashboardModule = DashboardModule;
+exports.DashboardModule = DashboardModule = DashboardModule_1 = __decorate([
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(STORAGE_TOKEN)),
+    __param(1, (0, common_1.Inject)(OPTIONS_TOKEN)),
     __metadata("design:paramtypes", [storage_abstract_1.Storage, Object])
-], JobsTrackerService);
+], DashboardModule);

package/dist/decorators/job-concurrency.d.ts

@@ -1,5 +1,5 @@
-import type { Storage } from '../storage/storage.abstract';
-export interface QueuedEntry {
+import { Storage } from '../storage/storage.abstract';
+interface QueueEntry {
     instance: unknown;
     args: unknown[];
     jobName: string;
@@ -10,13 +10,13 @@ export interface QueuedEntry {
 }
 export declare function isOverlapping(jobName: string, noOverlap: boolean): boolean;
 export declare function isConcurrencyLimitReached(): boolean;
-declare function onJobStart(jobName: string): void;
-declare function onJobEnd(jobName: string): void;
-export declare function registerRunningExecution(executionId: string, jobName: string, storage: Storage): void;
-export declare function unregisterRunningExecution(executionId: string): void;
-export declare function wasExecutionStopped(executionId: string): boolean;
-export declare function consumeStoppedExecution(executionId: string): boolean;
+export declare function onJobStart(jobName: string): void;
+export declare function onJobEnd(jobName: string): void;
+export declare function enqueueEntry(entry: QueueEntry): void;
+export declare function registerRunningExecution(id: string, jobName: string, storage: Storage): void;
+export declare function unregisterRunningExecution(id: string): void;
+export declare function wasExecutionStopped(id: string): boolean;
+export declare function consumeStoppedExecution(id: string): boolean;
 export declare function stopExecutionById(executionId: string): boolean;
-export declare function enqueueEntry(entry: QueuedEntry): void;
-export declare function runEntry(entry: QueuedEntry): void;
-export { onJobStart, onJobEnd };
+export declare function runEntry(entry: QueueEntry): void;
+export {};

package/dist/decorators/job-concurrency.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isOverlapping = isOverlapping;
 exports.isConcurrencyLimitReached = isConcurrencyLimitReached;
+exports.onJobStart = onJobStart;
+exports.onJobEnd = onJobEnd;
+exports.enqueueEntry = enqueueEntry;
 exports.registerRunningExecution = registerRunningExecution;
 exports.unregisterRunningExecution = unregisterRunningExecution;
 exports.wasExecutionStopped = wasExecutionStopped;
 exports.consumeStoppedExecution = consumeStoppedExecution;
 exports.stopExecutionById = stopExecutionById;
-exports.enqueueEntry = enqueueEntry;
 exports.runEntry = runEntry;
-exports.onJobStart = onJobStart;
-exports.onJobEnd = onJobEnd;
 const scheduler_dash_context_1 = require("../scheduler-dash.context");
 let runningCount = 0;
 const runningJobs = new Set();
@@ -33,17 +33,20 @@ function onJobEnd(jobName) {
     runningJobs.delete(jobName);
     drainQueue();
 }
-function registerRunningExecution(executionId, jobName, storage) {
-    runningExecutions.set(executionId, { jobName, storage });
+function enqueueEntry(entry) {
+    queue.push(entry);
+}
+function registerRunningExecution(id, jobName, storage) {
+    runningExecutions.set(id, { jobName, storage });
 }
-function unregisterRunningExecution(executionId) {
-    runningExecutions.delete(executionId);
+function unregisterRunningExecution(id) {
+    runningExecutions.delete(id);
 }
-function wasExecutionStopped(executionId) {
-    return stoppedExecutions.has(executionId);
+function wasExecutionStopped(id) {
+    return stoppedExecutions.has(id);
 }
-function consumeStoppedExecution(executionId) {
-    return stoppedExecutions.delete(executionId);
+function consumeStoppedExecution(id) {
+    return stoppedExecutions.delete(id);
 }
 function stopExecutionById(executionId) {
     const queueIdx = queue.findIndex(e => e.executionId === executionId);
@@ -62,47 +65,39 @@ function stopExecutionById(executionId) {
     }
     return false;
 }
-function enqueueEntry(entry) {
-    queue.push(entry);
-}
-function nextEligibleIndex() {
-    return queue.findIndex(e => !e.noOverlap || !runningJobs.has(e.jobName));
-}
 function drainQueue() {
-    const max = scheduler_dash_context_1.SchedulerDashContext.maxConcurrent;
-    if (max === undefined)
-        return;
-    while (runningCount < max) {
-        const idx = nextEligibleIndex();
-        if (idx === -1)
-            break;
-        const [entry] = queue.splice(idx, 1);
+    while (queue.length > 0 && !isConcurrencyLimitReached()) {
+        const entry = queue.shift();
+        if (isOverlapping(entry.jobName, entry.noOverlap)) {
+            entry.storage.update(entry.executionId, { finishedAt: new Date(), status: 'stopped' });
+            continue;
+        }
         runEntry(entry);
     }
 }
-function formatError(err) {
-    return err instanceof Error ? (err.stack ?? err.message) : String(err);
-}
 function runEntry(entry) {
     const { instance, args, jobName, executionId, original, storage } = entry;
+    storage.update(executionId, { status: 'running' });
     onJobStart(jobName);
     registerRunningExecution(executionId, jobName, storage);
-    storage.update(executionId, { status: 'running' });
-    Promise.resolve(original.apply(instance, args))
-        .then(() => {
-        if (!wasExecutionStopped(executionId)) {
-            storage.update(executionId, { finishedAt: new Date(), status: 'completed' });
+    (async () => {
+        try {
+            await original.apply(instance, args);
+            if (!wasExecutionStopped(executionId)) {
+                storage.update(executionId, { finishedAt: new Date(), status: 'completed' });
+            }
         }
-    })
-        .catch((err) => {
-        if (!wasExecutionStopped(executionId)) {
-            storage.update(executionId, { finishedAt: new Date(), status: 'failed', error: formatError(err) });
+        catch (err) {
+            if (!wasExecutionStopped(executionId)) {
+                const error = err instanceof Error ? (err.stack ?? err.message) : String(err);
+                storage.update(executionId, { finishedAt: new Date(), status: 'failed', error });
+            }
         }
-    })
-        .finally(() => {
-        unregisterRunningExecution(executionId);
-        if (!consumeStoppedExecution(executionId)) {
-            onJobEnd(jobName);
+        finally {
+            unregisterRunningExecution(executionId);
+            if (!consumeStoppedExecution(executionId)) {
+                onJobEnd(jobName);
+            }
         }
-    });
+    })();
 }

package/dist/decorators/track-job.decorator.js

@@ -8,9 +8,6 @@ const job_concurrency_1 = require("./job-concurrency");
 function formatError(err) {
     return err instanceof Error ? (err.stack ?? err.message) : String(err);
 }
-function resolveNoOverlap(jobNoOverlap) {
-    return jobNoOverlap ?? scheduler_dash_context_1.SchedulerDashContext.noOverlap;
-}
 async function runWithoutStorage(instance, args, jobName, original) {
     (0, job_concurrency_1.onJobStart)(jobName);
     try {
@@ -55,10 +52,10 @@ function queueExecution(instance, args, jobName, noOverlap, original) {
 function TrackJob(cronTime, options) {
     return (target, propertyKey, descriptor) => {
         const original = descriptor.value;
-        const jobName = options?.name ?? String(propertyKey);
+        const jobName = options?.name ?? `${target.constructor.name}.${String(propertyKey)}`;
         const jobNoOverlap = options?.noOverlap;
         descriptor.value = async function (...args) {
-            const noOverlap = resolveNoOverlap(jobNoOverlap);
+            const noOverlap = jobNoOverlap ?? scheduler_dash_context_1.SchedulerDashContext.noOverlap;
             const storage = scheduler_dash_context_1.SchedulerDashContext.storage;
             if ((0, job_concurrency_1.isOverlapping)(jobName, noOverlap))
                 return;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { INestApplication } from '@nestjs/common';
+import type { INestApplication } from '@nestjs/common';
 import { SchedulerDashOptions } from './scheduler-dash.options';
 export { TrackJob } from './decorators/track-job.decorator';
 export { Storage } from './storage/storage.abstract';