@punks/backend-entity-manager 0.0.366 → 0.0.367

package/dist/cjs/index.js

@@ -4262,6 +4262,19 @@ const WpEntitySnapshotService = (entityName, props = {}) => common.applyDecorato
     ...props,
 }));
 
+const TASK_KEY = "wp_task";
+var TaskConcurrency;
+(function (TaskConcurrency) {
+    TaskConcurrency["Single"] = "single";
+    TaskConcurrency["Multiple"] = "multiple";
+})(TaskConcurrency || (TaskConcurrency = {}));
+function WpTask(name, settings) {
+    return common.applyDecorators(common.Injectable(), common.SetMetadata(TASK_KEY, {
+        name,
+        ...settings,
+    }));
+}
+
 const WpEventsTracker = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EventsTracker, {
     ...props,
 }));
@@ -34781,6 +34794,164 @@ exports.JobsModule = JobsModule_1 = __decorate([
         JobsProviderFactory])
 ], exports.JobsModule);
 
+var TaskRunType;
+(function (TaskRunType) {
+    TaskRunType["Scheduled"] = "Scheduled";
+    TaskRunType["OnDemand"] = "OnDemand";
+})(TaskRunType || (TaskRunType = {}));
+
+const getCronCurrentSchedule = (cronExpression, ref) => {
+    const interval = parser$1.parseExpression(cronExpression, {
+        currentDate: ref,
+    });
+    return interval.prev().toDate();
+};
+
+function floorDateToSecond(date) {
+    const flooredDate = new Date(date);
+    flooredDate.setMilliseconds(0);
+    return flooredDate;
+}
+
+var TaskShell_1;
+let TaskShell = TaskShell_1 = class TaskShell {
+    constructor(registry, operations) {
+        this.registry = registry;
+        this.operations = operations;
+        this.logger = backendCore.Log.getLogger(TaskShell_1.name);
+    }
+    async executeTask(instance, settings) {
+        switch (settings.concurrency) {
+            case TaskConcurrency.Single:
+                return await this.executeTaskSequential(instance, settings);
+            case TaskConcurrency.Multiple:
+                return await this.executeTaskParallel(instance, settings);
+            default:
+                throw new Error(`Unknown task concurrency: ${settings.concurrency}`);
+        }
+    }
+    async executeTaskParallel(instance, settings) {
+        await this.invokeTask(instance, settings);
+    }
+    async executeTaskSequential(instance, settings) {
+        const currentSchedule = getCronCurrentSchedule(settings.cronExpression, new Date());
+        const lockKey = this.getTaskLockKey(settings, currentSchedule);
+        const lock = await this.operations.acquireLock({
+            lockUid: lockKey,
+        });
+        if (lock.available) {
+            await this.invokeTask(instance, settings);
+        }
+    }
+    getTaskLockKey(settings, cronSchedule) {
+        return `task:${settings.name}:${floorDateToSecond(cronSchedule).toISOString()}`;
+    }
+    async invokeTask(instance, settings) {
+        try {
+            this.logger.info(`Task ${settings.name} -> starting`);
+            await instance.execute({
+                name: settings.name,
+                startedAt: new Date(),
+                runId: backendCore.newUuid(),
+                runType: TaskRunType.Scheduled,
+            });
+            this.logger.info(`Task ${settings.name} -> completed`);
+        }
+        catch (error) {
+            this.logger.exception(`Task ${settings.name} -> failed`, error);
+        }
+    }
+    get operationsLockService() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveOperationLockService();
+    }
+};
+TaskShell = TaskShell_1 = __decorate([
+    common.Injectable(),
+    __param(1, common.Inject(getEntityManagerProviderToken("OperationsLockRepository"))),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry, Object])
+], TaskShell);
+
+var TaskScheduler_1;
+let TaskScheduler = TaskScheduler_1 = class TaskScheduler {
+    constructor(schedulerRegistry, jobShell) {
+        this.schedulerRegistry = schedulerRegistry;
+        this.jobShell = jobShell;
+        this.logger = new common.Logger(TaskScheduler_1.name);
+        this.jobs = [];
+    }
+    async registerTask(job, instance) {
+        const cronJob = new dist.CronJob(job.cronExpression, async (context) => {
+            await this.jobShell.executeTask(instance, job);
+        });
+        this.schedulerRegistry.addCronJob(job.name, cronJob);
+        cronJob.start();
+        this.jobs.push(cronJob);
+        this.logger.log(`Jobs ${job.name} registered`);
+    }
+    stopAllTasks() {
+        this.jobs.forEach((job) => {
+            job.stop();
+        });
+    }
+};
+TaskScheduler = TaskScheduler_1 = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [schedule.SchedulerRegistry,
+        TaskShell])
+], TaskScheduler);
+
+var TasksInitializer_1;
+let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
+    constructor(discover, scheduler) {
+        this.discover = discover;
+        this.scheduler = scheduler;
+        this.logger = new common.Logger(TasksInitializer_1.name);
+    }
+    async initialize(app) {
+        await this.registerCronJobs();
+        this.logger.log("Tasks initialized 🎰");
+    }
+    async registerCronJobs() {
+        const tasks = await this.discoverTasks();
+        const duplicatedJobs = tasks.filter((job, index, self) => index !== self.findIndex((t) => t.meta.name === job.meta.name));
+        if (duplicatedJobs.length) {
+            throw new Error(`Duplicated jobs found: ${duplicatedJobs
+                .map((j) => j.meta.name)
+                .join(", ")}`);
+        }
+        for (const task of tasks) {
+            await this.scheduler.registerTask(task.meta, task.discoveredClass.instance);
+        }
+    }
+    async discoverTasks() {
+        return await this.discover.providersWithMetaAtKey(TASK_KEY);
+    }
+};
+TasksInitializer = TasksInitializer_1 = __decorate([
+    WpAppInitializer(),
+    __metadata("design:paramtypes", [exports.CustomDiscoveryService,
+        TaskScheduler])
+], TasksInitializer);
+
+exports.TasksModule = class TasksModule {
+    constructor(scheduler) {
+        this.scheduler = scheduler;
+    }
+    onModuleDestroy() {
+        this.scheduler.stopAllTasks();
+    }
+};
+exports.TasksModule = __decorate([
+    common.Module({
+        imports: [exports.EntityManagerModule],
+        providers: [TasksInitializer, TaskScheduler, TaskShell],
+    }),
+    __metadata("design:paramtypes", [TaskScheduler])
+], exports.TasksModule);
+
 const createExpressFileResponse = (res, file) => {
     res.set({
         "Content-Type": file.contentType,
@@ -44556,6 +44727,7 @@ exports.WpPermissionsService = WpPermissionsService;
 exports.WpPipeline = WpPipeline;
 exports.WpRolesService = WpRolesService;
 exports.WpSendgridEmailTemplate = WpSendgridEmailTemplate;
+exports.WpTask = WpTask;
 exports.WpUserRolesService = WpUserRolesService;
 exports.WpUserService = WpUserService;
 exports.awsBatchSettings = awsBatchSettings;