@solidxai/core 0.1.6 → 0.1.8-beta.0

package/src/services/queues/rabbitmq-subscriber.service.ts

@@ -6,9 +6,20 @@ import { MqMessageQueueService } from '../mq-message-queue.service';
 import { MqMessageService } from '../mq-message.service';
 import { buildNamespacedQueueName } from './common';
 
+class ConsumerProcessingTimeoutError extends Error {
+    constructor(
+        readonly queueName: string,
+        readonly messageId: string,
+        readonly timeoutMs: number,
+    ) {
+        super(`Subscriber processing timed out after ${timeoutMs}ms for queue ${queueName} and messageId ${messageId}`);
+        this.name = 'ConsumerProcessingTimeoutError';
+    }
+}
+
 
 export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscriber<T> { // TODO This can be made a generic type for better type visibility
-    private readonly logger = new Logger(RabbitMqSubscriber.name);
+    private _loggerInstance?: Logger;
     private readonly url: string;
     private readonly serviceRole: string;
     private connection: amqp.Connection | null = null;
@@ -30,10 +41,25 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         // this.logger.debug(`RabbitMqSubscriber instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
     }
 
+    protected get loggerContext(): string {
+        return this.constructor.name;
+    }
+
+    protected get logger(): Logger {
+        if (!this._loggerInstance) {
+            this._loggerInstance = new Logger(this.loggerContext);
+        }
+        return this._loggerInstance;
+    }
+
     abstract subscribe(message: QueueMessage<T>);
 
     abstract options(): QueuesModuleOptions;
 
+    protected shouldPersistToDatabase(): boolean {
+        return this.options().persistToDatabase ?? true;
+    }
+
     async establishConnection(): Promise<amqp.Connection> {
 
         const url = new URL(this.url);
@@ -62,9 +88,15 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'rabbitmq';
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
         const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
+        const roleAllowed = ['both', 'subscriber'].includes(this.serviceRole);
+
+        if (!roleAllowed) {
+            this.logger.log(`RabbitMqSubscriber is disabled because QUEUES_SERVICE_ROLE is "${this.serviceRole}". Expected "both" or "subscriber".`);
+            return;
+        }
 
         // we will start subscriber only if the current service role is subscriber. 
-        if (this.url && ['both', 'subscriber'].includes(this.serviceRole) && solidCliRunning === "false" && defaultBroker === 'rabbitmq') {
+        if (this.url && solidCliRunning === "false" && defaultBroker === 'rabbitmq') {
             const options = this.options();
             const queueName = options.queueName;
 
@@ -102,6 +134,10 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         if (prefetch < 1) {
             throw new Error(`RabbitMqSubscriber prefetch must be >= 1 for queue ${queueName}`);
         }
+        const processingTimeoutMs = this.resolveProcessingTimeoutMs();
+        if (processingTimeoutMs > 0) {
+            this.logger.log(`RabbitMqSubscriber using processing timeout ${processingTimeoutMs}ms for queue ${queueName}`);
+        }
 
         let connection: amqp.Connection;
         try {
@@ -186,7 +222,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 if (!message.currentRetry) message.currentRetry = 0;
 
                 try {
-                    await this.processMessage(message, rawMessage, channel);
+                    await this.processMessage(message, rawMessage, channel, queueName);
                 } catch (error) {
                     await this.handleProcessingError(message, rawMessage, channel, error, queueName);
                 }
@@ -201,10 +237,12 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     // Retry flow: update DB -> increment retry -> send to retry queue with per-message expiration -> ack original.
     private async handleProcessingError(message: QueueMessage<T>, rawMessage: amqp.ConsumeMessage, channel: amqp.Channel, error: any, queueName: string): Promise<void> {
         const errorMessage = (error as Error)?.message || String(error);
-        this.logger.error(`Error processing message on queue ${queueName}: ${errorMessage}`);
+        this.logger.error(`Error processing message on queue ${queueName}: ${errorMessage}`, (error as Error)?.stack);
 
         if (message.currentRetry < message.retryCount) {
-            await this.updateStatusInDatabase('retrying', message);
+            if (this.shouldPersistToDatabase()) {
+                await this.updateStatusInDatabase('retrying', message);
+            }
 
             message.currentRetry++;
             const retryQueue = `${queueName}.retry`;
@@ -222,8 +260,9 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
             this.logger.warn(`Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms on queue ${queueName}`);
             return;
         }
-
-        await this.updateStatusInDatabase('failed', message, errorMessage, '');
+        if (this.shouldPersistToDatabase()) {
+            await this.updateStatusInDatabase('failed', message, errorMessage, '');
+        }
         channel.ack(rawMessage);
         await this.publishToFailedQueue(queueName, Buffer.from(JSON.stringify(message)), channel, error);
         this.logger.error(`Message failed after ${message.retryCount} attempts on queue ${queueName}: ${errorMessage}`);
@@ -322,17 +361,21 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     /**
      * Abstract method for message processing logic.
      */
-    protected async processMessage(message: QueueMessage<T>, rawMessage, channel): Promise<void> {
-        await this.updateStatusInDatabase('started', message);
+    protected async processMessage(message: QueueMessage<T>, rawMessage, channel, queueName: string): Promise<void> {
+        if (this.shouldPersistToDatabase()) {
+            await this.updateStatusInDatabase('started', message);
+        }
 
         // Capture the results of handling the task.
-        const result = await this.subscribe(message);
+        const result = await this.subscribeWithTimeout(message, queueName);
 
         // Ack the message. 
         channel.ack(rawMessage);
 
         // Persist success output and timing.
-        await this.updateStatusInDatabase('succeeded', message, '', result ? JSON.stringify(result, null, 2) : '');
+        if (this.shouldPersistToDatabase()) {
+            await this.updateStatusInDatabase('succeeded', message, '', result ? JSON.stringify(result, null, 2) : '');
+        }
 
     }
 
@@ -370,4 +413,89 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
 
     }
 
+    private resolveProcessingTimeoutMs(): number {
+        // Broker-side delivery-ack timeout (ms). If not provided, assume RabbitMQ default
+        // behavior used in this project: 30 minutes.
+        // Example (RabbitMQ broker):
+        // - Broker ack timeout: 30m => 1,800,000ms (QUEUES_RABBITMQ_CONSUMER_ACK_TIMEOUT_MS)
+        // - App soft timeout should be slightly lower, e.g. 29m30s => 1,770,000ms
+        //   (QUEUES_RABBITMQ_SUBSCRIBER_PROCESSING_TIMEOUT_MS), so application code fails first,
+        //   records DB state/error, and avoids broker-forced channel close as primary failure signal.
+        const brokerTimeoutMs = this.parsePositiveInt(process.env.QUEUES_RABBITMQ_CONSUMER_ACK_TIMEOUT_MS, 30 * 60 * 1000);
+
+        // Soft timeout should fire *before* broker timeout so we can fail explicitly,
+        // persist status/error, and avoid broker-forced channel closure as primary signal.
+        // Keep at least 1s to avoid zero/negative values when broker timeout is very small.
+        const defaultSoftTimeoutMs = Math.max(1_000, brokerTimeoutMs - 30_000);
+
+        // Final timeout precedence:
+        // 1) QUEUES_RABBITMQ_SUBSCRIBER_PROCESSING_TIMEOUT_MS (if valid positive int)
+        // 2) Derived defaultSoftTimeoutMs (broker timeout - 30s)
+        return this.parsePositiveInt(process.env.QUEUES_RABBITMQ_SUBSCRIBER_PROCESSING_TIMEOUT_MS, defaultSoftTimeoutMs);
+    }
+
+    private parsePositiveInt(value: string | undefined, fallback: number): number {
+        // Shared env parsing helper:
+        // - missing/invalid/non-positive => fallback
+        // - valid positive integer => parsed value
+        if (!value) return fallback;
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    }
+
+    private async subscribeWithTimeout(message: QueueMessage<T>, queueName: string): Promise<any> {
+        const timeoutMs = this.resolveProcessingTimeoutMs();
+        const messageId = message?.messageId || 'unknown';
+
+        // Allow an escape hatch: non-positive timeout means run without a soft timeout.
+        if (timeoutMs <= 0) {
+            return this.subscribe(message);
+        }
+
+        let timedOut = false;
+        let timeoutHandle: NodeJS.Timeout | null = null;
+
+        // Main subscriber work promise.
+        // If timeout has already fired, suppress rethrow to avoid unhandled rejection noise
+        // (the timeout error is already the authoritative failure we track).
+        const subscribePromise = this.subscribe(message).catch((error) => {
+            if (timedOut) {
+                this.logger.error(
+                    `Subscriber promise rejected after timeout for queue ${queueName} and messageId ${messageId}: ${(error as Error)?.message || String(error)}`,
+                    (error as Error)?.stack,
+                );
+                return undefined;
+            }
+            throw error;
+        });
+
+        // Timeout promise rejects after timeoutMs with an explicit domain-specific error.
+        const timeoutPromise = new Promise<never>((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                reject(new ConsumerProcessingTimeoutError(queueName, messageId, timeoutMs));
+            }, timeoutMs);
+        });
+
+        try {
+            // Promise.race settles as soon as the *first* promise settles.
+            // - If subscribePromise resolves/rejects first, we use that outcome.
+            // - If timeoutPromise rejects first, we fail fast with timeout error.
+            // This ensures we mark DB status via normal error handling before broker ack-timeout.
+            return await Promise.race([subscribePromise, timeoutPromise]);
+        } catch (error) {
+            const errorMessage = (error as Error)?.message || String(error);
+            this.logger.error(
+                `Subscriber execution failed for queue ${queueName} and messageId ${messageId}: ${errorMessage}`,
+                (error as Error)?.stack,
+            );
+            throw error;
+        } finally {
+            // Always clear timer once race settles to avoid timer leaks.
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+    }
+
 }

package/src/services/queues/redis-publisher.service.ts

@@ -0,0 +1,94 @@
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import Redis from 'ioredis';
+import { v4 as uuidv4 } from 'uuid';
+import { QueuesModuleOptions } from '../../interfaces';
+import { QueueMessage, QueuePublisher } from '../../interfaces/mq';
+import { MqMessageQueueService } from '../mq-message-queue.service';
+import { MqMessageService } from '../mq-message.service';
+import { buildNamespacedQueueName } from './common';
+
+export abstract class RedisPublisher<T> implements OnModuleDestroy, QueuePublisher<T> {
+    private readonly logger = new Logger(RedisPublisher.name);
+    private readonly serviceRole: string;
+    private client: Redis | null = null;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
+        if (!process.env.QUEUES_REDIS_URL) {
+            this.logger.debug('RedisPublisher: QUEUES_REDIS_URL is not defined in the environment variables');
+        }
+    }
+
+    abstract options(): QueuesModuleOptions;
+
+    private getClient(): Redis {
+        if (!this.client) {
+            this.client = new Redis(process.env.QUEUES_REDIS_URL);
+            this.client.on('error', (err) => {
+                this.logger.error(`RedisPublisher connection error: ${err.message}`, err.stack);
+            });
+        }
+        return this.client;
+    }
+
+    async onModuleDestroy(): Promise<void> {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+        }
+    }
+
+    async publish(message: QueueMessage<T>): Promise<string> {
+        if (!process.env.QUEUES_REDIS_URL) {
+            throw new Error('RedisPublisher: QUEUES_REDIS_URL is not defined in the environment variables');
+        }
+        if (!this.serviceRole) {
+            throw new Error('RedisPublisher: Queue service Role is not defined in the environment variables');
+        }
+        if (this.serviceRole === 'subscriber') {
+            throw new Error('RedisPublisher: Queue service Role is subscriber, cannot publish messages');
+        }
+
+        if (!message.retryCount) message.retryCount = 0;
+        if (!message.retryInterval) message.retryInterval = 1000;
+        message.messageId = uuidv4();
+
+        const queueName = this.options().queueName;
+        const namespacedQueueName = buildNamespacedQueueName(queueName);
+
+        await this.persistToDatabase(namespacedQueueName, message);
+
+        try {
+            const client = this.getClient();
+            await client.publish(namespacedQueueName, JSON.stringify(message));
+            this.logger.debug(`RedisPublisher published message ${message.messageId} to channel ${namespacedQueueName}`);
+        } catch (err) {
+            this.logger.error(`RedisPublisher failed to publish message: ${(err as Error).message}`, (err as Error).stack);
+        }
+
+        return message.messageId;
+    }
+
+    private async persistToDatabase(queueName: string, message: QueueMessage<T>): Promise<void> {
+        try {
+            const mqMessageQueue = await this.mqMessageQueueService.resolveQueue(queueName);
+            await this.mqMessageService.create({
+                messageBroker: this.options().type,
+                messageId: message.messageId,
+                retryCount: message.retryCount,
+                retryInterval: message.retryInterval,
+                stage: 'pending',
+                startedAt: new Date(),
+                input: JSON.stringify(message, null, 2),
+                parentEntityId: message.parentEntityId,
+                parentEntity: message.parentEntity,
+                mqMessageQueueId: mqMessageQueue.id,
+            });
+        } catch (error) {
+            this.logger.error(error.message, error.stack);
+        }
+    }
+}

package/src/services/queues/redis-subscriber.service.ts

@@ -0,0 +1,208 @@
+import { Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import Redis from 'ioredis';
+import { QueuesModuleOptions } from '../../interfaces';
+import { QueueMessage, QueueSubscriber } from '../../interfaces/mq';
+import { MqMessageQueueService } from '../mq-message-queue.service';
+import { MqMessageService } from '../mq-message.service';
+import { buildNamespacedQueueName } from './common';
+
+export abstract class RedisSubscriber<T> implements OnModuleInit, OnModuleDestroy, QueueSubscriber<T> {
+    private readonly logger = new Logger(RedisSubscriber.name);
+    private readonly serviceRole: string;
+    private client: Redis | null = null;
+    private reconnectAttempt = 0;
+    private stopping = false;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
+        if (!process.env.QUEUES_REDIS_URL) {
+            this.logger.debug('RedisSubscriber: QUEUES_REDIS_URL is not defined in the environment variables');
+        }
+    }
+
+    abstract subscribe(message: QueueMessage<T>): void;
+
+    abstract options(): QueuesModuleOptions;
+
+    async onModuleInit(): Promise<void> {
+        const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || 'false';
+        const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
+
+        if (
+            process.env.QUEUES_REDIS_URL &&
+            ['both', 'subscriber'].includes(this.serviceRole) &&
+            solidCliRunning === 'false' &&
+            defaultBroker === 'redis'
+        ) {
+            const options = this.options();
+            const queueName = options.queueName;
+
+            if (queueNameRegex && queueNameRegex !== 'all') {
+                try {
+                    const regex = new RegExp(queueNameRegex);
+                    if (!regex.test(queueName)) {
+                        this.logger.log(
+                            `RedisSubscriber for queue ${queueName} is disabled because it does not match QUEUES_QUEUE_NAME_REGEX_TO_ENABLE=${queueNameRegex}`,
+                        );
+                        return;
+                    }
+                } catch (error) {
+                    this.logger.error(
+                        `Invalid QUEUES_QUEUE_NAME_REGEX_TO_ENABLE regex "${queueNameRegex}". Subscriber for queue ${queueName} will not start.`,
+                    );
+                    return;
+                }
+            }
+
+            const namespacedQueueName = buildNamespacedQueueName(queueName);
+            await this.connectAndSubscribe(namespacedQueueName);
+            this.logger.log(`RedisSubscriber ready to consume messages: ${JSON.stringify(options)}`);
+        }
+    }
+
+    async onModuleDestroy(): Promise<void> {
+        this.stopping = true;
+        await this.cleanup();
+    }
+
+    private async connectAndSubscribe(channel: string): Promise<void> {
+        await this.cleanup();
+
+        const client = new Redis(process.env.QUEUES_REDIS_URL);
+        this.client = client;
+
+        client.on('error', (err) => {
+            if (client !== this.client) return;
+            this.logger.error(`RedisSubscriber connection error for channel ${channel}: ${err.message}`, err.stack);
+        });
+
+        client.on('close', () => {
+            if (client !== this.client) return;
+            this.logger.warn(`RedisSubscriber connection closed for channel ${channel}`);
+            this.triggerReconnect(channel, 'connection closed');
+        });
+
+        client.on('message', async (receivedChannel, rawMessage) => {
+            if (receivedChannel !== channel) return;
+
+            let message: QueueMessage<T> = null;
+            try {
+                message = JSON.parse(rawMessage) as QueueMessage<T>;
+            } catch (error) {
+                this.logger.error(`RedisSubscriber invalid JSON on channel ${channel}: ${(error as Error).message}`);
+                return;
+            }
+
+            if (!message.retryCount) message.retryCount = 0;
+            if (!message.retryInterval) message.retryInterval = 1000;
+            if (!message.currentRetry) message.currentRetry = 0;
+
+            try {
+                await this.processMessage(message);
+            } catch (error) {
+                await this.handleProcessingError(message, error, channel);
+            }
+        });
+
+        await client.subscribe(channel);
+        this.reconnectAttempt = 0;
+    }
+
+    private async handleProcessingError(message: QueueMessage<T>, error: any, channel: string): Promise<void> {
+        const errorMessage = (error as Error)?.message || String(error);
+        this.logger.error(`Error processing message on channel ${channel}: ${errorMessage}`);
+
+        if (message.currentRetry < message.retryCount) {
+            await this.updateStatusInDatabase('retrying', message);
+            message.currentRetry++;
+            this.logger.warn(
+                `Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms on channel ${channel}`,
+            );
+            setTimeout(async () => {
+                try {
+                    await this.processMessage(message);
+                } catch (retryError) {
+                    await this.handleProcessingError(message, retryError, channel);
+                }
+            }, message.retryInterval);
+        } else {
+            await this.updateStatusInDatabase('failed', message, errorMessage, '');
+            this.logger.error(`Message failed after ${message.retryCount} attempts on channel ${channel}: ${errorMessage}`);
+        }
+    }
+
+    private triggerReconnect(channel: string, reason: string): void {
+        if (this.stopping) return;
+
+        this.reconnectAttempt++;
+        const delay = this.backoff();
+        this.logger.warn(`RedisSubscriber reconnecting for channel ${channel} (${reason}) in ${delay}ms`);
+
+        setTimeout(async () => {
+            if (this.stopping) return;
+            try {
+                await this.connectAndSubscribe(channel);
+                this.logger.log(`RedisSubscriber reconnected for channel ${channel}`);
+            } catch (err) {
+                this.triggerReconnect(channel, `reconnect failed: ${(err as Error).message}`);
+            }
+        }, delay);
+    }
+
+    private async cleanup(): Promise<void> {
+        const client = this.client;
+        this.client = null;
+
+        if (client) {
+            try {
+                await client.quit();
+            } catch (_) {
+                // ignore
+            }
+        }
+    }
+
+    private backoff(): number {
+        const baseMs = 1000;
+        const maxMs = 30_000;
+        const exp = Math.min(maxMs, baseMs * Math.pow(2, this.reconnectAttempt));
+        const jitter = Math.floor(Math.random() * (exp * 0.2));
+        return Math.min(maxMs, exp + jitter);
+    }
+
+    protected async processMessage(message: QueueMessage<T>): Promise<void> {
+        await this.updateStatusInDatabase('started', message);
+        const result: any = await (this.subscribe(message) as any);
+        await this.updateStatusInDatabase('succeeded', message, '', result != null ? JSON.stringify(result, null, 2) : '');
+    }
+
+    private async updateStatusInDatabase(
+        stage: string,
+        message: QueueMessage<T>,
+        error: string = '',
+        result: string = '',
+    ): Promise<void> {
+        try {
+            const mqMessage = await this.mqMessageService.repo.findOne({
+                where: { messageId: message.messageId },
+            });
+
+            if (mqMessage) {
+                const updatedFields: Record<string, any> = { stage };
+                if (stage === 'failed' || stage === 'succeeded') {
+                    updatedFields['finishedAt'] = new Date();
+                    updatedFields['elapsedMillis'] = updatedFields['finishedAt'].getTime() - mqMessage.startedAt.getTime();
+                }
+                if (stage === 'succeeded') updatedFields['output'] = result;
+                if (stage === 'failed') updatedFields['error'] = error;
+                await this.mqMessageService.repo.update(mqMessage.id, updatedFields);
+            }
+        } catch (err) {
+            this.logger.error(err.message, err.stack);
+        }
+    }
+}

package/src/services/request-context.service.ts

@@ -2,6 +2,7 @@ import { Injectable } from "@nestjs/common";
 import { ClsService } from "nestjs-cls";
 import { REQUEST_USER_KEY } from "src/constants";
 import { BasicFilterDto } from "src/dtos/basic-filters.dto";
+import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 
 @Injectable()
 export class RequestContextService {
@@ -9,7 +10,7 @@ export class RequestContextService {
     }
 
     // This method i.e getActiveUser() will fetch the user from the request object in the context
-    getActiveUser() {
+    getActiveUser(): ActiveUserData | undefined {
         return this.cls.get(REQUEST_USER_KEY);
     }
 

package/src/services/scheduled-job.service.ts

@@ -1,10 +1,12 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { ScheduledJob } from 'src/entities/scheduled-job.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
 import { EntityManager } from 'typeorm';
 import { CRUDService } from './crud.service';
+import { SchedulerServiceImpl } from './scheduled-jobs/scheduler.service';
 
 @Injectable()
 export class ScheduledJobService extends CRUDService<ScheduledJob> {
@@ -16,9 +18,36 @@ export class ScheduledJobService extends CRUDService<ScheduledJob> {
     // @InjectRepository(ScheduledJob)
     // readonly repo: Repository<ScheduledJob>,
     readonly repo: ScheduledJobRepository,
-    readonly moduleRef: ModuleRef
+    readonly moduleRef: ModuleRef,
+    private readonly solidRegistry: SolidRegistry,
+    private readonly schedulerService: SchedulerServiceImpl,
 
   ) {
     super(entityManager, repo, 'scheduledJob', 'solid-core', moduleRef);
   }
+
+  async triggerRun(id: number): Promise<ScheduledJob> {
+    const job = await this.repo.findOne({ where: { id } });
+    if (!job) {
+      throw new NotFoundException(`Scheduled job with id ${id} not found`);
+    }
+
+    const handler = this.solidRegistry.getScheduledJobProviderInstance(job.job);
+    if (!handler) {
+      throw new BadRequestException(`Scheduled job handler not found: ${job.job}`);
+    }
+
+    this.logger.log(`Manually triggering scheduled job id=${job.id}, job=${job.job}`);
+
+    await handler.execute(job);
+
+    const finishedAt = new Date();
+    job.lastRunAt = finishedAt;
+    job.nextRunAt = this.schedulerService.computeNextRunAt(job, finishedAt);
+    await this.repo.save(job);
+
+    this.logger.log(`Completed manual trigger for scheduled job id=${job.id}, nextRunAt=${job.nextRunAt?.toISOString?.()}`);
+
+    return job;
+  }
 }

package/src/services/scheduled-jobs/scheduler.interface.ts

@@ -1,3 +1,6 @@
+import { ScheduledJob } from "src/entities/scheduled-job.entity";
+
 export interface ISchedulerService {
     runScheduledJobs(): Promise<void>;
-}
+    computeNextRunAt(job: ScheduledJob, from: Date): Date;
+}