@luisrodrigues/nestjs-scheduler-dashboard 0.0.1

package/dist/auth.d.ts

@@ -0,0 +1,5 @@
+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;

package/dist/auth.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBasicAuth = checkBasicAuth;
+exports.rejectUnauthorized = rejectUnauthorized;
+exports.createAuthGuard = createAuthGuard;
+function checkBasicAuth(req, auth) {
+    const header = req.headers['authorization'] ?? '';
+    if (!header.startsWith('Basic '))
+        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;
+}
+function rejectUnauthorized(res) {
+    res.writeHead(401, {
+        'WWW-Authenticate': 'Basic realm="Scheduler Dashboard"',
+        'Content-Type': 'text/plain',
+    });
+    res.end('Unauthorized');
+}
+function createAuthGuard(auth) {
+    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');
+        }
+        next();
+    };
+}

package/dist/basic-auth.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { SchedulerDashOptions } from './scheduler-dash.options';
+export declare class BasicAuthGuard implements CanActivate {
+    private readonly options;
+    constructor(options: SchedulerDashOptions);
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/basic-auth.guard.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicAuthGuard = void 0;
+const common_1 = require("@nestjs/common");
+const scheduler_dash_options_1 = require("./scheduler-dash.options");
+let BasicAuthGuard = class BasicAuthGuard {
+    constructor(options) {
+        this.options = options;
+    }
+    canActivate(context) {
+        if (!this.options.auth)
+            return true;
+        const req = context.switchToHttp().getRequest();
+        const res = context.switchToHttp().getResponse();
+        const header = req.headers['authorization'] ?? '';
+        if (header.startsWith('Basic ')) {
+            const decoded = Buffer.from(header.slice(6), 'base64').toString('utf-8');
+            const [user, ...rest] = decoded.split(':');
+            if (user === this.options.auth.username && rest.join(':') === this.options.auth.password) {
+                return true;
+            }
+        }
+        res.setHeader('WWW-Authenticate', 'Basic realm="Scheduler Dashboard"');
+        throw new common_1.UnauthorizedException('Invalid credentials');
+    }
+};
+exports.BasicAuthGuard = BasicAuthGuard;
+exports.BasicAuthGuard = BasicAuthGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(scheduler_dash_options_1.SCHEDULER_DASH_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], BasicAuthGuard);

package/dist/dashboard.server.d.ts

@@ -0,0 +1,4 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { SchedulerDashAuth } from './scheduler-dash.options';
+import { JobsService } from './jobs.service';
+export declare function startDashboardServer(port: number, jobsService: JobsService, auth?: SchedulerDashAuth): import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/dashboard.server.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDashboardServer = startDashboardServer;
+const http_1 = require("http");
+const dashboard_1 = require("./ui/dashboard");
+function unauthorized(res) {
+    res.writeHead(401, {
+        'WWW-Authenticate': 'Basic realm="Scheduler Dashboard"',
+        'Content-Type': 'text/plain',
+    });
+    res.end('Unauthorized');
+}
+function json(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(payload);
+}
+function checkAuth(req, auth) {
+    const header = req.headers['authorization'] ?? '';
+    if (!header.startsWith('Basic '))
+        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;
+}
+async function readBody(req) {
+    return new Promise((resolve) => {
+        let body = '';
+        req.on('data', chunk => (body += chunk));
+        req.on('end', () => resolve(body));
+    });
+}
+function startDashboardServer(port, jobsService, auth) {
+    const server = (0, http_1.createServer)(async (req, res) => {
+        const url = req.url ?? '/';
+        const method = req.method ?? 'GET';
+        if (auth && !checkAuth(req, auth)) {
+            return unauthorized(res);
+        }
+        if (method === 'GET' && (url === '/' || url.startsWith('/jobs/'))) {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            return res.end(dashboard_1.dashboardHtml);
+        }
+        if (method === 'GET' && url === '/api') {
+            return json(res, 200, jobsService.getJobs());
+        }
+        const actionMatch = url.match(/^\/api\/([^/]+)\/trigger$/);
+        if (method === 'POST' && actionMatch) {
+            await readBody(req);
+            const name = decodeURIComponent(actionMatch[1]);
+            const ok = jobsService.triggerJob(name);
+            if (!ok)
+                return json(res, 404, { message: `Job "${name}" not found` });
+            return json(res, 200, { triggered: name });
+        }
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not Found');
+    });
+    server.listen(port, () => {
+        console.log(`[SchedulerDash] Dashboard running at http://localhost:${port}`);
+    });
+    return server;
+}

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

@@ -0,0 +1,22 @@
+import type { Storage } from '../storage/storage.abstract';
+export interface QueuedEntry {
+    instance: unknown;
+    args: unknown[];
+    jobName: string;
+    executionId: string;
+    noOverlap: boolean;
+    original: (...a: unknown[]) => unknown;
+    storage: Storage;
+}
+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 stopExecutionById(executionId: string): boolean;
+export declare function enqueueEntry(entry: QueuedEntry): void;
+export declare function runEntry(entry: QueuedEntry): void;
+export { onJobStart, onJobEnd };

package/dist/decorators/job-concurrency.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOverlapping = isOverlapping;
+exports.isConcurrencyLimitReached = isConcurrencyLimitReached;
+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();
+const queue = [];
+const runningExecutions = new Map();
+const stoppedExecutions = new Set();
+function isOverlapping(jobName, noOverlap) {
+    return noOverlap && runningJobs.has(jobName);
+}
+function isConcurrencyLimitReached() {
+    const max = scheduler_dash_context_1.SchedulerDashContext.maxConcurrent;
+    return max !== undefined && runningCount >= max;
+}
+function onJobStart(jobName) {
+    runningCount++;
+    runningJobs.add(jobName);
+}
+function onJobEnd(jobName) {
+    runningCount--;
+    runningJobs.delete(jobName);
+    drainQueue();
+}
+function registerRunningExecution(executionId, jobName, storage) {
+    runningExecutions.set(executionId, { jobName, storage });
+}
+function unregisterRunningExecution(executionId) {
+    runningExecutions.delete(executionId);
+}
+function wasExecutionStopped(executionId) {
+    return stoppedExecutions.has(executionId);
+}
+function consumeStoppedExecution(executionId) {
+    return stoppedExecutions.delete(executionId);
+}
+function stopExecutionById(executionId) {
+    const queueIdx = queue.findIndex(e => e.executionId === executionId);
+    if (queueIdx !== -1) {
+        const [entry] = queue.splice(queueIdx, 1);
+        entry.storage.update(executionId, { finishedAt: new Date(), status: 'stopped' });
+        return true;
+    }
+    const running = runningExecutions.get(executionId);
+    if (running) {
+        stoppedExecutions.add(executionId);
+        runningExecutions.delete(executionId);
+        running.storage.update(executionId, { finishedAt: new Date(), status: 'stopped' });
+        onJobEnd(running.jobName);
+        return true;
+    }
+    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);
+        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;
+    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' });
+        }
+    })
+        .catch((err) => {
+        if (!wasExecutionStopped(executionId)) {
+            storage.update(executionId, { finishedAt: new Date(), status: 'failed', error: formatError(err) });
+        }
+    })
+        .finally(() => {
+        unregisterRunningExecution(executionId);
+        if (!consumeStoppedExecution(executionId)) {
+            onJobEnd(jobName);
+        }
+    });
+}

package/dist/decorators/track-job.decorator.d.ts

@@ -0,0 +1,6 @@
+import { Cron } from '@nestjs/schedule';
+import type { CronOptions } from '@nestjs/schedule';
+export type TrackJobOptions = CronOptions & {
+    noOverlap?: boolean;
+};
+export declare function TrackJob(cronTime: Parameters<typeof Cron>[0], options?: TrackJobOptions): MethodDecorator;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackJob = TrackJob;
+const schedule_1 = require("@nestjs/schedule");
+const crypto_1 = require("crypto");
+const scheduler_dash_context_1 = require("../scheduler-dash.context");
+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 {
+        return await original.apply(instance, args);
+    }
+    finally {
+        (0, job_concurrency_1.onJobEnd)(jobName);
+    }
+}
+async function runImmediately(instance, args, jobName, original) {
+    const storage = scheduler_dash_context_1.SchedulerDashContext.storage;
+    const id = (0, crypto_1.randomUUID)();
+    storage.save({ id, jobName, startedAt: new Date(), finishedAt: null, status: 'running' });
+    (0, job_concurrency_1.onJobStart)(jobName);
+    (0, job_concurrency_1.registerRunningExecution)(id, jobName, storage);
+    try {
+        const result = await original.apply(instance, args);
+        if (!(0, job_concurrency_1.wasExecutionStopped)(id)) {
+            storage.update(id, { finishedAt: new Date(), status: 'completed' });
+        }
+        return result;
+    }
+    catch (err) {
+        if (!(0, job_concurrency_1.wasExecutionStopped)(id)) {
+            storage.update(id, { finishedAt: new Date(), status: 'failed', error: formatError(err) });
+        }
+        throw err;
+    }
+    finally {
+        (0, job_concurrency_1.unregisterRunningExecution)(id);
+        if (!(0, job_concurrency_1.consumeStoppedExecution)(id)) {
+            (0, job_concurrency_1.onJobEnd)(jobName);
+        }
+    }
+}
+function queueExecution(instance, args, jobName, noOverlap, original) {
+    const storage = scheduler_dash_context_1.SchedulerDashContext.storage;
+    const id = (0, crypto_1.randomUUID)();
+    storage.save({ id, jobName, startedAt: new Date(), finishedAt: null, status: 'queued' });
+    (0, job_concurrency_1.enqueueEntry)({ instance, args, jobName, executionId: id, noOverlap, original, storage });
+}
+function TrackJob(cronTime, options) {
+    return (target, propertyKey, descriptor) => {
+        const original = descriptor.value;
+        const jobName = options?.name ?? String(propertyKey);
+        const jobNoOverlap = options?.noOverlap;
+        descriptor.value = async function (...args) {
+            const noOverlap = resolveNoOverlap(jobNoOverlap);
+            const storage = scheduler_dash_context_1.SchedulerDashContext.storage;
+            if ((0, job_concurrency_1.isOverlapping)(jobName, noOverlap))
+                return;
+            if (!storage)
+                return runWithoutStorage(this, args, jobName, original);
+            if ((0, job_concurrency_1.isConcurrencyLimitReached)()) {
+                queueExecution(this, args, jobName, noOverlap, original);
+                return;
+            }
+            return runImmediately(this, args, jobName, original);
+        };
+        const { noOverlap: _, ...cronOptions } = options ?? {};
+        (0, schedule_1.Cron)(cronTime, { name: jobName, ...cronOptions })(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}

package/dist/embedded-server.d.ts

@@ -0,0 +1,4 @@
+import { INestApplication, Logger } from '@nestjs/common';
+import { JobsService } from './jobs.service';
+import { SchedulerDashAuth } from './scheduler-dash.options';
+export declare function mountOnApp(app: INestApplication, basePath: string, jobsService: JobsService, auth: SchedulerDashAuth | undefined, logger: Logger): void;

package/dist/embedded-server.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountOnApp = mountOnApp;
+const auth_1 = require("./auth");
+const dashboard_1 = require("./ui/dashboard");
+const PLACEHOLDER = '__SCHEDULER_BASE_PLACEHOLDER__';
+function renderHtml(base) {
+    return dashboard_1.dashboardHtml.replace(PLACEHOLDER, base);
+}
+function registerUiRoutes(expressApp, base, guard) {
+    const html = renderHtml(base);
+    expressApp.get(base, guard, (_req, res) => {
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        res.send(html);
+    });
+    expressApp.get(`${base}/jobs/*`, guard, (_req, res) => {
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        res.send(html);
+    });
+}
+function registerApiRoutes(expressApp, base, guard, jobsService) {
+    expressApp.get(`${base}/api`, guard, (_req, res) => {
+        res.json(jobsService.getJobs());
+    });
+    expressApp.post(`${base}/api/:name/trigger`, guard, (req, res) => {
+        const name = decodeURIComponent(req.params.name);
+        const ok = jobsService.triggerJob(name);
+        if (!ok)
+            return res.status(404).json({ message: `Job "${name}" not found` });
+        res.json({ triggered: name });
+    });
+    expressApp.post(`${base}/api/executions/:id/stop`, guard, (req, res) => {
+        const id = decodeURIComponent(req.params.id);
+        const ok = jobsService.stopExecution(id);
+        if (!ok)
+            return res.status(404).json({ message: `Execution "${id}" not found or already finished` });
+        res.json({ stopped: id });
+    });
+}
+function mountOnApp(app, basePath, jobsService, auth, logger) {
+    const base = `/${basePath}`;
+    const expressApp = app.getHttpAdapter().getInstance();
+    const guard = (0, auth_1.createAuthGuard)(auth);
+    registerUiRoutes(expressApp, base, guard);
+    registerApiRoutes(expressApp, base, guard, jobsService);
+    logger.log(`Dashboard available at ${base}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { INestApplication } from '@nestjs/common';
+import { SchedulerDashOptions } from './scheduler-dash.options';
+export { TrackJob } from './decorators/track-job.decorator';
+export { Storage } from './storage/storage.abstract';
+export type { IStorageOptions } from './storage/storage.abstract';
+export { MemoryStorage } from './storage/memory.storage';
+export type { JobExecution } from './storage/job-execution.interface';
+export type { JobMetrics } from './storage/job-metrics.interface';
+export type { SchedulerDashOptions, SchedulerDashAuth } from './scheduler-dash.options';
+export declare function setupSchedulerDash(app: INestApplication, options?: SchedulerDashOptions): Promise<void>;

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = exports.Storage = exports.TrackJob = void 0;
+exports.setupSchedulerDash = setupSchedulerDash;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const scheduler_dash_context_1 = require("./scheduler-dash.context");
+const scheduler_dash_schema_1 = require("./scheduler-dash.schema");
+const jobs_service_1 = require("./jobs.service");
+const memory_storage_1 = require("./storage/memory.storage");
+const standalone_server_1 = require("./standalone-server");
+const embedded_server_1 = require("./embedded-server");
+var track_job_decorator_1 = require("./decorators/track-job.decorator");
+Object.defineProperty(exports, "TrackJob", { enumerable: true, get: function () { return track_job_decorator_1.TrackJob; } });
+var storage_abstract_1 = require("./storage/storage.abstract");
+Object.defineProperty(exports, "Storage", { enumerable: true, get: function () { return storage_abstract_1.Storage; } });
+var memory_storage_2 = require("./storage/memory.storage");
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return memory_storage_2.MemoryStorage; } });
+async function setupSchedulerDash(app, options = {}) {
+    const parsed = scheduler_dash_schema_1.SchedulerDashOptionsSchema.safeParse(options);
+    if (!parsed.success) {
+        throw new Error(`[SchedulerDash] Invalid options:\n${parsed.error.issues.map(i => `  • ${i.path.join('.')}: ${i.message}`).join('\n')}`);
+    }
+    const storage = options.storage ?? new memory_storage_1.MemoryStorage({
+        historyRetention: 10
+    });
+    const basePath = (options.basePath ?? '_jobs').replace(/^\//, '');
+    const logger = new common_1.Logger('SchedulerDash-Dashboard', { timestamp: true });
+    scheduler_dash_context_1.SchedulerDashContext.storage = storage;
+    scheduler_dash_context_1.SchedulerDashContext.basePath = basePath;
+    scheduler_dash_context_1.SchedulerDashContext.noOverlap = options.noOverlap ?? false;
+    scheduler_dash_context_1.SchedulerDashContext.maxConcurrent = options.maxConcurrent;
+    const schedulerRegistry = app.get(schedule_1.SchedulerRegistry);
+    const jobsService = new jobs_service_1.JobsService(schedulerRegistry, storage);
+    if (options.port) {
+        (0, standalone_server_1.startStandaloneServer)(options.port, basePath, jobsService, options.auth, logger);
+    }
+    else {
+        (0, embedded_server_1.mountOnApp)(app, basePath, jobsService, options.auth, logger);
+    }
+}

package/dist/jobs-tracker.service.d.ts

@@ -0,0 +1,9 @@
+import { SchedulerDashOptions } from './scheduler-dash.options';
+import { Storage } from './storage/storage.abstract';
+export declare class JobsTrackerService {
+    private readonly storage;
+    private readonly options;
+    private readonly logger;
+    constructor(storage: Storage, options: SchedulerDashOptions);
+    onModuleInit(): void;
+}

package/dist/jobs-tracker.service.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsTrackerService = 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 {
+    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`);
+    }
+};
+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)),
+    __metadata("design:paramtypes", [storage_abstract_1.Storage, Object])
+], JobsTrackerService);

package/dist/jobs.controller.d.ts

@@ -0,0 +1,25 @@
+import { JobsService } from './jobs.service';
+export declare class JobsController {
+    private readonly jobsService;
+    constructor(jobsService: JobsService);
+    dashboard(): string;
+    dashboardDetail(): string;
+    getJobs(): {
+        cron: {
+            name: string;
+            cronExpression: any;
+            running: boolean;
+            nextRun: string;
+            history: import(".").JobExecution[];
+        }[];
+        intervals: {
+            name: string;
+        }[];
+        timeouts: {
+            name: string;
+        }[];
+    };
+    triggerJob(name: string): {
+        triggered: string;
+    };
+}

package/dist/jobs.controller.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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;
+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 {
+    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`);
+        return { triggered: name };
+    }
+};
+exports.JobsController = JobsController;
+__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);
+__decorate([
+    (0, common_1.Get)('api'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], JobsController.prototype, "getJobs", null);
+__decorate([
+    (0, common_1.Post)('api/:name/trigger'),
+    __param(0, (0, common_1.Param)('name')),
+    __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),
+    __metadata("design:paramtypes", [jobs_service_1.JobsService])
+], JobsController);

package/dist/jobs.service.d.ts

@@ -0,0 +1,25 @@
+import { SchedulerRegistry } from '@nestjs/schedule';
+import { Storage } from './storage/storage.abstract';
+export declare class JobsService {
+    private readonly schedulerRegistry;
+    private readonly storage;
+    constructor(schedulerRegistry: SchedulerRegistry, storage: Storage);
+    getJobs(): {
+        cron: {
+            name: string;
+            cronExpression: any;
+            running: boolean;
+            nextRun: string;
+            history: import(".").JobExecution[];
+            metrics: import(".").JobMetrics;
+        }[];
+        intervals: {
+            name: string;
+        }[];
+        timeouts: {
+            name: string;
+        }[];
+    };
+    triggerJob(name: string): boolean;
+    stopExecution(executionId: string): boolean;
+}