fix(api-headless-cms-scheduler): executor

Author: brunozoric

packages/api-headless-cms-scheduler/__tests__/scheduler/ScheduleExecutor.test.ts

@@ -3,14 +3,30 @@ import { createMockService } from "~tests/mocks/service.js";
 import { createMockScheduleModel } from "~tests/mocks/scheduleModel.js";
 import { createMockCms } from "~tests/mocks/cms.js";
 import { createMockFetcher } from "~tests/mocks/fetcher.js";
+import { type IScheduleRecord, ScheduleType } from "~/scheduler/types.js";
+import { createScheduleRecord } from "~/scheduler/ScheduleRecord.js";
+import { createMockGetIdentity } from "~tests/mocks/getIdentity.js";
 
 describe("ScheduleExecutor", () => {
     const service = createMockService();
     const scheduleModel = createMockScheduleModel();
     const cms = createMockCms();
-    const fetcher = createMockFetcher();
 
     it("should execute not find action for publishing", async () => {
+        const fetcher = createMockFetcher({
+            async getScheduled(targetId: string): Promise<IScheduleRecord> {
+                return createScheduleRecord({
+                    id: `schedule-record-id-${targetId}`,
+                    targetId,
+                    scheduledOn: new Date(),
+                    dateOn: new Date(),
+                    type: ScheduleType.publish,
+                    title: `Scheduled for ${targetId}`,
+                    scheduledBy: createMockGetIdentity()(),
+                    model: {} as any
+                });
+            }
+        });
         const executor = new ScheduleExecutor({
             actions: [],
             scheduleModel,
@@ -21,13 +37,31 @@ describe("ScheduleExecutor", () => {
 
         await expect(
             executor.schedule("target-id#0001", {
-                type: "publish",
-                dateOn: new Date()
+                type: ScheduleType.publish,
+                scheduleOn: new Date()
             })
-        ).rejects.toThrow(`No action found for input type "publish"`);
+        ).rejects.toThrow(`No action found for input type "${ScheduleType.publish}"`);
+
+        await expect(executor.cancel("target-id#0001")).rejects.toThrow(
+            `No action found for input type "${ScheduleType.publish}"`
+        );
     });
 
     it("should execute not find action for unpublishing", async () => {
+        const fetcher = createMockFetcher({
+            async getScheduled(targetId: string): Promise<IScheduleRecord> {
+                return createScheduleRecord({
+                    id: `schedule-record-id-${targetId}`,
+                    targetId,
+                    scheduledOn: new Date(),
+                    dateOn: new Date(),
+                    type: ScheduleType.unpublish,
+                    title: `Scheduled for ${targetId}`,
+                    scheduledBy: createMockGetIdentity()(),
+                    model: {} as any
+                });
+            }
+        });
         const executor = new ScheduleExecutor({
             actions: [],
             scheduleModel,
@@ -38,9 +72,13 @@ describe("ScheduleExecutor", () => {
 
         await expect(
             executor.schedule("target-id#0001", {
-                type: "unpublish",
-                dateOn: new Date()
+                type: ScheduleType.unpublish,
+                scheduleOn: new Date()
             })
-        ).rejects.toThrow(`No action found for input type "unpublish"`);
+        ).rejects.toThrow(`No action found for input type "${ScheduleType.unpublish}"`);
+
+        await expect(executor.cancel("target-id#0001")).rejects.toThrow(
+            `No action found for input type "${ScheduleType.unpublish}"`
+        );
     });
 });

packages/api-headless-cms-scheduler/src/scheduler/ScheduleExecutor.ts

@@ -1,14 +1,13 @@
 import type { CmsModel } from "@webiny/api-headless-cms/types";
-import type {
-    IScheduleAction,
-    IScheduleExecutor,
-    IScheduleFetcher,
-    IScheduleRecord,
-    ISchedulerInput
+import {
+    type IScheduleAction,
+    type IScheduleExecutor,
+    type IScheduleFetcher,
+    type IScheduleRecord,
+    type ISchedulerInput,
+    ScheduleType
 } from "~/scheduler/types.js";
 import { createScheduleRecordId } from "~/scheduler/createScheduleRecordId.js";
-import { convertException } from "@webiny/utils";
-import { NotFoundError } from "@webiny/handler-graphql";
 import type { ISchedulerService } from "~/service/types.js";
 import type { PublishScheduleActionCms } from "~/scheduler/actions/PublishScheduleAction.js";
 import type { UnpublishScheduleActionCms } from "~/scheduler/actions/UnpublishScheduleAction.js";
@@ -43,16 +42,7 @@ export class ScheduleExecutor implements IScheduleExecutor {
         const scheduleRecordId = createScheduleRecordId(targetId);
         const original = await this.fetcher.getScheduled(targetId);
 
-        const action = this.actions.find(action => action.canHandle(input));
-        if (!action) {
-            throw new WebinyError(
-                `No action found for input type "${input.type}".`,
-                "NO_ACTION_FOUND",
-                {
-                    type: input.type
-                }
-            );
-        }
+        const action = this.getAction(input.type);
 
         if (original) {
             return action.reschedule(original, input);
@@ -66,28 +56,32 @@ export class ScheduleExecutor implements IScheduleExecutor {
     }
 
     public async cancel(id: string): Promise<void> {
-        const record = await this.fetcher.getScheduled(id);
-        if (!record) {
-            return;
+        const original = await this.fetcher.getScheduled(id);
+        if (!original) {
+            throw new WebinyError(
+                `No scheduled record found for ID "${id}".`,
+                "SCHEDULED_RECORD_NOT_FOUND",
+                {
+                    id
+                }
+            );
         }
 
-        try {
-            await this.cms.deleteEntry(this.scheduleModel, record.id);
-        } catch (ex) {
-            if (ex.code === "NOT_FOUND" || ex instanceof NotFoundError) {
-                return;
-            }
-            console.error(`Error while deleting scheduled record: ${id}.`);
-            console.log(convertException(ex));
-            throw ex;
-        }
+        const action = this.getAction(original.type);
+        return action.cancel(original.id);
+    }
 
-        const result = await this.service.delete(record.id);
-        if (!result.error) {
-            return;
-        } else if (result.error.code === "NOT_FOUND" || result.error instanceof NotFoundError) {
-            return;
+    private getAction(type: ScheduleType): IScheduleAction {
+        const action = this.actions.find(action => {
+            return action.canHandle({
+                type
+            });
+        });
+        if (action) {
+            return action;
         }
-        throw result.error;
+        throw new WebinyError(`No action found for input type "${type}".`, "NO_ACTION_FOUND", {
+            type
+        });
     }
 }

packages/api-headless-cms-scheduler/src/scheduler/types.ts

@@ -94,7 +94,7 @@ export interface IScheduleActionScheduleParams {
     input: ISchedulerInput;
 }
 export interface IScheduleAction {
-    canHandle(input: ISchedulerInput): boolean;
+    canHandle(input: Pick<ISchedulerInput, "type">): boolean;
     schedule(params: IScheduleActionScheduleParams): Promise<IScheduleRecord>;
     cancel(id: string): Promise<void>;
     reschedule(original: IScheduleRecord, input: ISchedulerInput): Promise<IScheduleRecord>;