@punks/backend-entity-manager 0.0.369 → 0.0.371

package/dist/cjs/index.js

@@ -34820,40 +34820,42 @@ let TaskShell = TaskShell_1 = class TaskShell {
         this.operations = operations;
         this.logger = backendCore.Log.getLogger(TaskShell_1.name);
     }
-    async executeTask(instance, settings) {
+    async executeTask(instance, settings, runType) {
         switch (settings.concurrency) {
             case exports.TaskConcurrency.Single:
-                return await this.executeTaskSequential(instance, settings);
+                return await this.executeTaskSequential(instance, settings, runType);
             case exports.TaskConcurrency.Multiple:
-                return await this.executeTaskParallel(instance, settings);
+                return await this.executeTaskParallel(instance, settings, runType);
             default:
                 throw new Error(`Unknown task concurrency: ${settings.concurrency}`);
         }
     }
-    async executeTaskParallel(instance, settings) {
-        await this.invokeTask(instance, settings);
+    async executeTaskParallel(instance, settings, runType) {
+        await this.invokeTask(instance, settings, runType);
     }
-    async executeTaskSequential(instance, settings) {
-        const currentSchedule = getCronCurrentSchedule(settings.cronExpression, new Date());
+    async executeTaskSequential(instance, settings, runType) {
+        const currentSchedule = settings.cronExpression && runType === exports.TaskRunType.Scheduled
+            ? getCronCurrentSchedule(settings.cronExpression, new Date())
+            : undefined;
         const lockKey = this.getTaskLockKey(settings, currentSchedule);
         const lock = await this.operations.acquireLock({
             lockUid: lockKey,
         });
         if (lock.available) {
-            await this.invokeTask(instance, settings);
+            await this.invokeTask(instance, settings, runType);
         }
     }
     getTaskLockKey(settings, cronSchedule) {
-        return `task:${settings.name}:${floorDateToSecond(cronSchedule).toISOString()}`;
+        return `task:${settings.name}:${cronSchedule ? floorDateToSecond(cronSchedule).toISOString() : backendCore.newUuid()}`;
     }
-    async invokeTask(instance, settings) {
+    async invokeTask(instance, settings, runType) {
         try {
             this.logger.info(`Task ${settings.name} -> starting`);
             await instance.execute({
                 name: settings.name,
                 startedAt: new Date(),
                 runId: backendCore.newUuid(),
-                runType: exports.TaskRunType.Scheduled,
+                runType,
             });
             this.logger.info(`Task ${settings.name} -> completed`);
         }
@@ -34880,19 +34882,22 @@ let TaskScheduler = TaskScheduler_1 = class TaskScheduler {
         this.schedulerRegistry = schedulerRegistry;
         this.jobShell = jobShell;
         this.logger = new common.Logger(TaskScheduler_1.name);
-        this.jobs = [];
+        this.cronJobs = [];
     }
-    async registerTask(job, instance) {
+    async scheduleTask(job, instance) {
+        if (!job.cronExpression) {
+            throw new Error(`Task ${job.name} has no cron expression`);
+        }
         const cronJob = new dist.CronJob(job.cronExpression, async (context) => {
-            await this.jobShell.executeTask(instance, job);
+            await this.jobShell.executeTask(instance, job, exports.TaskRunType.Scheduled);
         });
         this.schedulerRegistry.addCronJob(job.name, cronJob);
         cronJob.start();
-        this.jobs.push(cronJob);
+        this.cronJobs.push(cronJob);
         this.logger.log(`Jobs ${job.name} registered`);
     }
     stopAllTasks() {
-        this.jobs.forEach((job) => {
+        this.cronJobs.forEach((job) => {
             job.stop();
         });
     }
@@ -34903,11 +34908,40 @@ TaskScheduler = TaskScheduler_1 = __decorate([
         TaskShell])
 ], TaskScheduler);
 
+let TasksRegistry = class TasksRegistry {
+    constructor() {
+        this.tasks = new Map();
+    }
+    registerTask(props, instance) {
+        if (this.tasks.has(props.name)) {
+            throw new Error(`Task with name ${props.name} already registered`);
+        }
+        this.tasks.set(props.name, {
+            instance,
+            props,
+        });
+    }
+    getTask(name) {
+        const task = this.tasks.get(name);
+        if (!task) {
+            throw new Error(`Task with name ${name} not found`);
+        }
+        return task;
+    }
+    getTasks() {
+        return Array.from(this.tasks.values());
+    }
+};
+TasksRegistry = __decorate([
+    common.Injectable()
+], TasksRegistry);
+
 var TasksInitializer_1;
 let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
-    constructor(discover, scheduler) {
+    constructor(discover, scheduler, registry) {
         this.discover = discover;
         this.scheduler = scheduler;
+        this.registry = registry;
         this.logger = new common.Logger(TasksInitializer_1.name);
     }
     async initialize(app) {
@@ -34923,7 +34957,10 @@ let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
                 .join(", ")}`);
         }
         for (const task of tasks) {
-            await this.scheduler.registerTask(task.meta, task.discoveredClass.instance);
+            this.registry.registerTask(task.meta, task.discoveredClass.instance);
+            if (task.meta.cronExpression) {
+                await this.scheduler.scheduleTask(task.meta, task.discoveredClass.instance);
+            }
         }
     }
     async discoverTasks() {
@@ -34933,9 +34970,50 @@ let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
 TasksInitializer = TasksInitializer_1 = __decorate([
     WpAppInitializer(),
     __metadata("design:paramtypes", [exports.CustomDiscoveryService,
-        TaskScheduler])
+        TaskScheduler,
+        TasksRegistry])
 ], TasksInitializer);
 
+const TasksModuleProviders = [TaskScheduler, TaskShell, TasksRegistry];
+
+var TasksService_1;
+exports.TasksService = TasksService_1 = class TasksService {
+    constructor(jobShell, registry) {
+        this.jobShell = jobShell;
+        this.registry = registry;
+        this.logger = new common.Logger(TasksService_1.name);
+    }
+    async triggerTask(name) {
+        this.logger.log(`Manual task ${name} -> trigger`);
+        const task = this.registry.getTask(name);
+        this.jobShell
+            .executeTask(task.instance, task.props, exports.TaskRunType.OnDemand)
+            .then(() => {
+            this.logger.log(`Manual task ${name} -> completed`);
+        })
+            .catch((e) => {
+            this.logger.error(`Manual task ${name} -> error: ${e.message}`);
+        });
+        this.logger.log(`Manual task ${name} -> triggered`);
+    }
+    async invokeTask(name) {
+        this.logger.log(`Manual task ${name} -> invoke`);
+        const task = this.registry.getTask(name);
+        await this.jobShell.executeTask(task.instance, task.props, exports.TaskRunType.OnDemand);
+        this.logger.log(`Manual task ${name} -> completed`);
+    }
+    async getTasks() {
+        return this.registry.getTasks();
+    }
+};
+exports.TasksService = TasksService_1 = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [TaskShell,
+        TasksRegistry])
+], exports.TasksService);
+
+const TaskModuleServices = [exports.TasksService];
+
 exports.TasksModule = class TasksModule {
     constructor(scheduler) {
         this.scheduler = scheduler;
@@ -34947,7 +35025,8 @@ exports.TasksModule = class TasksModule {
 exports.TasksModule = __decorate([
     common.Module({
         imports: [exports.EntityManagerModule],
-        providers: [TasksInitializer, TaskScheduler, TaskShell],
+        providers: [TasksInitializer, ...TasksModuleProviders, ...TaskModuleServices],
+        exports: [...TaskModuleServices],
     }),
     __metadata("design:paramtypes", [TaskScheduler])
 ], exports.TasksModule);