@punks/backend-entity-manager 0.0.282 → 0.0.284

package/dist/cjs/index.js

@@ -33784,10 +33784,11 @@ JobsMonitorTask = JobsMonitorTask_1 = __decorate([
     __metadata("design:paramtypes", [Object, Object, cqrs.CommandBus])
 ], JobsMonitorTask);
 
+const jobsSettings = new AppInMemorySettings();
+
 var JobsScheduler_1;
 let JobsScheduler = JobsScheduler_1 = class JobsScheduler {
-    constructor(jobsSettings, schedulerRegistry, schedulerTask, monitorTask) {
-        this.jobsSettings = jobsSettings;
+    constructor(schedulerRegistry, schedulerTask, monitorTask) {
         this.schedulerRegistry = schedulerRegistry;
         this.schedulerTask = schedulerTask;
         this.monitorTask = monitorTask;
@@ -33823,18 +33824,78 @@ let JobsScheduler = JobsScheduler_1 = class JobsScheduler {
         this.registerJobsScheduler();
         this.registerJobsMonitor();
     }
+    get jobsSettings() {
+        return jobsSettings.value;
+    }
 };
 JobsScheduler = JobsScheduler_1 = __decorate([
     common.Injectable(),
-    __param(0, common.Inject(getEntityManagerProviderToken("JobsModuleSettings"))),
-    __metadata("design:paramtypes", [Object, schedule.SchedulerRegistry,
+    __metadata("design:paramtypes", [schedule.SchedulerRegistry,
         JobsSchedulerTask,
         JobsMonitorTask])
 ], JobsScheduler);
 
 const JobsProviders = [JobsScheduler];
 
-const JobsServices = [];
+class JobDefinitionUpdateCommand {
+    constructor(input) {
+        this.input = input;
+    }
+}
+
+exports.JobsService = class JobsService {
+    constructor(definitions, instances, commandBus) {
+        this.definitions = definitions;
+        this.instances = instances;
+        this.commandBus = commandBus;
+        this.triggerJob = async (input) => {
+            const job = await this.definitions.getDefinitionByUid(input.jobUid);
+            if (!job) {
+                throw new Error(`Job ${input.jobUid} not found`);
+            }
+            const schedule = input.scheduleUid
+                ? job.schedules.find((x) => x.uid === input.scheduleUid)
+                : undefined;
+            if (input.scheduleUid && !schedule) {
+                throw new Error(`Job ${input.jobUid} schedule ${input.scheduleUid} not found`);
+            }
+            return await this.commandBus.execute(new JobDispatchCommand({
+                job,
+                schedule,
+                runType: exports.JobRunType.OnDemand,
+                payload: input.payload,
+            }));
+        };
+        this.updateJob = async (input) => {
+            this.commandBus.execute(new JobDefinitionUpdateCommand({
+                job: input,
+            }));
+        };
+        this.instanceMonitor = async (input) => {
+            const { instanceId } = input;
+            const instance = await this.instances.getById(instanceId);
+            if (!instance) {
+                throw new Error(`Job instance ${instanceId} not found`);
+            }
+            const job = await this.definitions.getDefinitionByUid(instance.jobUid);
+            if (!job) {
+                throw new Error(`Job definition ${instance.jobUid} not found`);
+            }
+            return await this.commandBus.execute(new JobStatusMonitorCommand({
+                instanceId,
+                job,
+            }));
+        };
+    }
+};
+exports.JobsService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(getEntityManagerProviderToken("JobDefinitionsRepository"))),
+    __param(1, common.Inject(getEntityManagerProviderToken("JobInstancesRepository"))),
+    __metadata("design:paramtypes", [Object, Object, cqrs.CommandBus])
+], exports.JobsService);
+
+const JobsServices = [exports.JobsService];
 
 const JOB_PROVIDER = Symbol.for("WP.JOB_PROVIDER");
 
@@ -33902,7 +33963,7 @@ let JobDispatchHandler = JobDispatchHandler_1 = class JobDispatchHandler {
         });
     }
     async dispatchJob(command) {
-        const { input: { job, schedule, runType }, } = command;
+        const { input: { job, schedule, runType, payload }, } = command;
         const instanceId = backendCore.newUuid();
         try {
             this.logger.info(`JOB DISPATCH -> dispatching started job ${job.uid} -> ${instanceId}`);
@@ -33916,6 +33977,7 @@ let JobDispatchHandler = JobDispatchHandler_1 = class JobDispatchHandler {
                 definition: job,
                 schedule,
                 instanceId,
+                payload,
             });
             await this.instances.updateInstance(instanceId, {
                 status: exports.JobStatus.Ready,
@@ -34006,12 +34068,6 @@ JobStatusMonitorHandler = JobStatusMonitorHandler_1 = __decorate([
         JobProviderExecutor, Object])
 ], JobStatusMonitorHandler);
 
-class JobDefinitionUpdateCommand {
-    constructor(input) {
-        this.input = input;
-    }
-}
-
 var JobDefinitionUpdateHandler_1;
 let JobDefinitionUpdateHandler = JobDefinitionUpdateHandler_1 = class JobDefinitionUpdateHandler {
     constructor(lock, definitions, executor) {
@@ -34077,16 +34133,10 @@ exports.JobsModule = JobsModule_1 = class JobsModule {
         await this.jobsProviderFactory.initialize();
     }
     static forRoot(input) {
+        jobsSettings.initialize(input);
         return {
             module: JobsModule_1,
             ...ModuleData$7,
-            providers: [
-                ...ModuleData$7.providers,
-                {
-                    provide: getEntityManagerProviderToken("JobsModuleSettings"),
-                    useValue: input,
-                },
-            ],
         };
     }
 };
@@ -40085,13 +40135,13 @@ let AwsJobsProvider = class AwsJobsProvider {
         this.awsBatchService = awsBatchService;
     }
     async dispatch(input) {
-        const { definition, schedule, instanceId } = input;
+        const { definition, schedule, instanceId, payload } = input;
         const awsInvocationParams = schedule?.invocationOverrides;
         await this.awsBatchService.submitJob({
             instanceId,
             jobUid: definition.uid,
             overrides: {
-                command: awsInvocationParams?.startCommand,
+                command: awsInvocationParams?.startCommand?.map((x) => x.replace("{payload}", JSON.stringify(payload ?? {}))),
             },
         });
     }