@luisrodrigues/nestjs-scheduler-dashboard 0.0.1

package/dist/jobs.service.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsService = void 0;
+const job_concurrency_1 = require("./decorators/job-concurrency");
+class JobsService {
+    constructor(schedulerRegistry, storage) {
+        this.schedulerRegistry = schedulerRegistry;
+        this.storage = storage;
+    }
+    getJobs() {
+        const cron = [...this.schedulerRegistry.getCronJobs().entries()].map(([name, job]) => ({
+            name,
+            cronExpression: job.cronTime.source?.toString() ?? null,
+            running: job.running ?? false,
+            nextRun: job.nextDate().toISO(),
+            history: this.storage.findByJob(name),
+            metrics: this.storage.getMetrics(name),
+        }));
+        const intervals = this.schedulerRegistry.getIntervals().map((name) => ({ name }));
+        const timeouts = this.schedulerRegistry.getTimeouts().map((name) => ({ name }));
+        return { cron, intervals, timeouts };
+    }
+    triggerJob(name) {
+        const job = this.schedulerRegistry.getCronJobs().get(name);
+        if (!job)
+            return false;
+        job.fireOnTick();
+        return true;
+    }
+    stopExecution(executionId) {
+        return (0, job_concurrency_1.stopExecutionById)(executionId);
+    }
+}
+exports.JobsService = JobsService;

package/dist/scheduler-dash.context.d.ts

@@ -0,0 +1,7 @@
+import { Storage } from './storage/storage.abstract';
+export declare class SchedulerDashContext {
+    static storage: Storage | null;
+    static basePath: string;
+    static noOverlap: boolean;
+    static maxConcurrent: number | undefined;
+}

package/dist/scheduler-dash.context.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerDashContext = void 0;
+class SchedulerDashContext {
+}
+exports.SchedulerDashContext = SchedulerDashContext;
+SchedulerDashContext.storage = null;
+SchedulerDashContext.basePath = '_jobs';
+SchedulerDashContext.noOverlap = false;
+SchedulerDashContext.maxConcurrent = undefined;

package/dist/scheduler-dash.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { SchedulerDashOptions } from './scheduler-dash.options';
+export declare class SchedulerDashModule {
+    static forRoot(options: SchedulerDashOptions): DynamicModule;
+}

package/dist/scheduler-dash.module.js

@@ -0,0 +1,39 @@
+"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 SchedulerDashModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerDashModule = void 0;
+const common_1 = require("@nestjs/common");
+const jobs_controller_1 = require("./jobs.controller");
+const jobs_service_1 = require("./jobs.service");
+const jobs_tracker_service_1 = require("./jobs-tracker.service");
+const basic_auth_guard_1 = require("./basic-auth.guard");
+const scheduler_dash_options_1 = require("./scheduler-dash.options");
+let SchedulerDashModule = SchedulerDashModule_1 = class SchedulerDashModule {
+    static forRoot(options) {
+        return {
+            module: SchedulerDashModule_1,
+            providers: [
+                { provide: scheduler_dash_options_1.SCHEDULER_DASH_OPTIONS, useValue: options },
+                { provide: scheduler_dash_options_1.SCHEDULER_DASH_STORAGE, useValue: options.storage },
+            ],
+        };
+    }
+};
+exports.SchedulerDashModule = SchedulerDashModule;
+exports.SchedulerDashModule = SchedulerDashModule = SchedulerDashModule_1 = __decorate([
+    (0, common_1.Module)({
+        controllers: [jobs_controller_1.JobsController],
+        providers: [
+            basic_auth_guard_1.BasicAuthGuard,
+            jobs_service_1.JobsService,
+            jobs_tracker_service_1.JobsTrackerService,
+        ],
+        exports: [jobs_service_1.JobsService],
+    })
+], SchedulerDashModule);

package/dist/scheduler-dash.options.d.ts

@@ -0,0 +1,13 @@
+import { Storage } from './storage/storage.abstract';
+export interface SchedulerDashAuth {
+    username: string;
+    password: string;
+}
+export interface SchedulerDashOptions {
+    storage?: Storage;
+    basePath?: string;
+    port?: number;
+    maxConcurrent?: number;
+    noOverlap?: boolean;
+    auth?: SchedulerDashAuth;
+}

package/dist/scheduler-dash.options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/scheduler-dash.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Storage } from './storage/storage.abstract';
+export declare const SchedulerDashAuthSchema: z.ZodObject<{
+    username: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const SchedulerDashOptionsSchema: z.ZodObject<{
+    storage: z.ZodOptional<z.ZodCustom<Storage, Storage>>;
+    basePath: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    maxConcurrent: z.ZodOptional<z.ZodNumber>;
+    noOverlap: z.ZodOptional<z.ZodBoolean>;
+    auth: z.ZodOptional<z.ZodObject<{
+        username: z.ZodString;
+        password: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/scheduler-dash.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerDashOptionsSchema = exports.SchedulerDashAuthSchema = void 0;
+const zod_1 = require("zod");
+const storage_abstract_1 = require("./storage/storage.abstract");
+exports.SchedulerDashAuthSchema = zod_1.z.object({
+    username: zod_1.z.string().min(1, 'auth.username must not be empty'),
+    password: zod_1.z.string().min(1, 'auth.password must not be empty'),
+});
+exports.SchedulerDashOptionsSchema = zod_1.z.object({
+    storage: zod_1.z.instanceof(storage_abstract_1.Storage).optional(),
+    basePath: zod_1.z
+        .string()
+        .regex(/^[a-zA-Z0-9_\-/]+$/, 'basePath must contain only alphanumeric characters, hyphens, underscores, or slashes')
+        .optional(),
+    port: zod_1.z
+        .number()
+        .int('port must be an integer')
+        .min(1, 'port must be >= 1')
+        .max(65535, 'port must be <= 65535')
+        .optional(),
+    maxConcurrent: zod_1.z
+        .number()
+        .int('maxConcurrent must be an integer')
+        .min(1, 'maxConcurrent must be >= 1')
+        .optional(),
+    noOverlap: zod_1.z.boolean().optional(),
+    auth: exports.SchedulerDashAuthSchema.optional(),
+});

package/dist/standalone-server.d.ts

@@ -0,0 +1,5 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { Logger } from '@nestjs/common';
+import { JobsService } from './jobs.service';
+import { SchedulerDashAuth } from './scheduler-dash.options';
+export declare function startStandaloneServer(port: number, basePath: string, jobsService: JobsService, auth: SchedulerDashAuth | undefined, logger: Logger): import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/standalone-server.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStandaloneServer = startStandaloneServer;
+const http_1 = require("http");
+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 sendHtml(res, base) {
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(renderHtml(base));
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+function handleGetApi(res, jobsService) {
+    sendJson(res, 200, jobsService.getJobs());
+}
+function handleTrigger(res, jobsService, encodedName) {
+    const name = decodeURIComponent(encodedName);
+    const ok = jobsService.triggerJob(name);
+    sendJson(res, ok ? 200 : 404, ok ? { triggered: name } : { message: `Job "${name}" not found` });
+}
+function handleNotFound(res) {
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found');
+}
+function handleStopExecution(res, jobsService, encodedId) {
+    const id = decodeURIComponent(encodedId);
+    const ok = jobsService.stopExecution(id);
+    sendJson(res, ok ? 200 : 404, ok ? { stopped: id } : { message: `Execution "${id}" not found or already finished` });
+}
+function createRequestHandler(base, jobsService, auth) {
+    const triggerRe = new RegExp(`^${base}/api/([^/]+)/trigger$`);
+    const stopExecutionRe = new RegExp(`^${base}/api/executions/([^/]+)/stop$`);
+    return (req, res) => {
+        const url = req.url ?? '/';
+        const method = req.method ?? 'GET';
+        if (auth && !(0, auth_1.checkBasicAuth)(req, auth)) {
+            return (0, auth_1.rejectUnauthorized)(res);
+        }
+        if (method === 'GET' && (url === base || url === `${base}/` || url.startsWith(`${base}/jobs/`))) {
+            return sendHtml(res, base);
+        }
+        if (method === 'GET' && url === `${base}/api`) {
+            return handleGetApi(res, jobsService);
+        }
+        const triggerMatch = url.match(triggerRe);
+        if (method === 'POST' && triggerMatch) {
+            return handleTrigger(res, jobsService, triggerMatch[1]);
+        }
+        const stopExecutionMatch = url.match(stopExecutionRe);
+        if (method === 'POST' && stopExecutionMatch) {
+            return handleStopExecution(res, jobsService, stopExecutionMatch[1]);
+        }
+        handleNotFound(res);
+    };
+}
+function startStandaloneServer(port, basePath, jobsService, auth, logger) {
+    const base = `/${basePath}`;
+    const handler = createRequestHandler(base, jobsService, auth);
+    const server = (0, http_1.createServer)(handler);
+    server.listen(port, () => {
+        logger.log(`Dashboard running at http://localhost:${port}${base}`);
+    });
+    return server;
+}

package/dist/storage/job-execution.interface.d.ts

@@ -0,0 +1,8 @@
+export interface JobExecution {
+    id: string;
+    jobName: string;
+    startedAt: Date;
+    finishedAt: Date | null;
+    status: 'running' | 'queued' | 'completed' | 'failed' | 'stopped';
+    error?: string;
+}

package/dist/storage/job-execution.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/job-metrics.interface.d.ts

@@ -0,0 +1,5 @@
+export interface JobMetrics {
+    totalRuns: number;
+    failedRuns: number;
+    avgDurationMs: number;
+}

package/dist/storage/job-metrics.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/memory.storage.d.ts

@@ -0,0 +1,16 @@
+import { Storage, IStorageOptions } from './storage.abstract';
+import { JobExecution } from './job-execution.interface';
+import { JobMetrics } from './job-metrics.interface';
+export declare class MemoryStorage extends Storage {
+    private readonly store;
+    private readonly metricsStore;
+    constructor(options?: IStorageOptions);
+    save(execution: JobExecution): void;
+    update(id: string, data: Partial<Pick<JobExecution, 'finishedAt' | 'status' | 'error'>>): void;
+    findByJob(jobName: string): JobExecution[];
+    findAll(): Record<string, JobExecution[]>;
+    getMetrics(jobName: string): JobMetrics;
+    getAllMetrics(): Record<string, JobMetrics>;
+    private recordMetric;
+    private toJobMetrics;
+}

package/dist/storage/memory.storage.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+const storage_abstract_1 = require("./storage.abstract");
+class MemoryStorage extends storage_abstract_1.Storage {
+    constructor(options = {}) {
+        super(options);
+        this.store = new Map();
+        this.metricsStore = new Map();
+    }
+    save(execution) {
+        const history = this.store.get(execution.jobName) ?? [];
+        history.push(execution);
+        if (this._options.historyRetention !== undefined && history.length > this._options.historyRetention) {
+            history.shift();
+        }
+        this.store.set(execution.jobName, history);
+    }
+    update(id, data) {
+        for (const [jobName, history] of this.store.entries()) {
+            const execution = history.find((e) => e.id === id);
+            if (!execution)
+                continue;
+            const wasFinished = execution.finishedAt !== null;
+            Object.assign(execution, data);
+            if (!wasFinished && data.finishedAt && data.status) {
+                this.recordMetric(jobName, execution, data.status);
+            }
+            return;
+        }
+    }
+    findByJob(jobName) {
+        return this.store.get(jobName) ?? [];
+    }
+    findAll() {
+        return Object.fromEntries(this.store.entries());
+    }
+    getMetrics(jobName) {
+        return this.toJobMetrics(this.metricsStore.get(jobName));
+    }
+    getAllMetrics() {
+        const result = {};
+        for (const [jobName, acc] of this.metricsStore.entries()) {
+            result[jobName] = this.toJobMetrics(acc);
+        }
+        return result;
+    }
+    recordMetric(jobName, execution, status) {
+        const acc = this.metricsStore.get(jobName) ?? { totalRuns: 0, failedRuns: 0, durationSum: 0, durationCount: 0 };
+        acc.totalRuns++;
+        if (status === 'failed') {
+            acc.failedRuns++;
+        }
+        if (execution.finishedAt) {
+            const duration = execution.finishedAt.getTime() - execution.startedAt.getTime();
+            acc.durationSum += duration;
+            acc.durationCount++;
+        }
+        this.metricsStore.set(jobName, acc);
+    }
+    toJobMetrics(acc) {
+        if (!acc)
+            return { totalRuns: 0, failedRuns: 0, avgDurationMs: 0 };
+        return {
+            totalRuns: acc.totalRuns,
+            failedRuns: acc.failedRuns,
+            avgDurationMs: acc.durationCount > 0 ? Math.round(acc.durationSum / acc.durationCount) : 0,
+        };
+    }
+}
+exports.MemoryStorage = MemoryStorage;

package/dist/storage/storage.abstract.d.ts

@@ -0,0 +1,15 @@
+import { JobExecution } from './job-execution.interface';
+import { JobMetrics } from './job-metrics.interface';
+export interface IStorageOptions {
+    historyRetention?: number;
+}
+export declare abstract class Storage {
+    protected readonly _options: IStorageOptions;
+    constructor(_options?: IStorageOptions);
+    abstract save(execution: JobExecution): void;
+    abstract update(id: string, data: Partial<Pick<JobExecution, 'finishedAt' | 'status' | 'error'>>): void;
+    abstract findByJob(jobName: string): JobExecution[];
+    abstract findAll(): Record<string, JobExecution[]>;
+    abstract getMetrics(jobName: string): JobMetrics;
+    abstract getAllMetrics(): Record<string, JobMetrics>;
+}

package/dist/storage/storage.abstract.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+class Storage {
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+}
+exports.Storage = Storage;