fix: finish scheduler implementation (#4884)

Author: Pavel910

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

@@ -45,7 +45,7 @@ describe("Action Handlers", () => {
             modelId: MOCK_TARGET_MODEL_ID,
             targetId: entryResult.value.id,
             actionType: "Publish",
-            scheduleOn: new Date(Date.now() + 100000).toISOString()
+            scheduleFor: new Date(Date.now() + 100000).toISOString()
         });
 
         // Assert scheduled actions
@@ -73,7 +73,7 @@ describe("Action Handlers", () => {
             modelId: MOCK_TARGET_MODEL_ID,
             targetId: entryResult.value.id,
             actionType: "Unpublish",
-            scheduleOn: new Date(Date.now() + 1000000).toISOString()
+            scheduleFor: new Date(Date.now() + 1000000).toISOString()
         });
 
         // Execute action handler

packages/api-headless-cms-scheduler/src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnDeleteHandler.ts

@@ -0,0 +1,52 @@
+import { EntryAfterDeleteHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
+import { ListScheduledActionsUseCase, CancelScheduledActionUseCase } from "@webiny/api-scheduler";
+
+/**
+ * Cancels scheduled actions when an entry is deleted
+ *
+ * When a user deletes an entry, any scheduled publish/unpublish
+ * actions for all of its revisions should be canceled since the entry
+ * no longer exists.
+ */
+class CancelScheduledActionOnEntryDeleteHandlerImpl implements EntryAfterDeleteHandler.Interface {
+    constructor(
+        private listScheduledActions: ListScheduledActionsUseCase.Interface,
+        private cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface
+    ) {}
+
+    async handle(event: EntryAfterDeleteHandler.Event): Promise<void> {
+        const { entry, model } = event.payload;
+
+        // Skip private models
+        if (model.isPrivate) {
+            return;
+        }
+
+        const schedules = await this.listSchedules(model.modelId, entry.entryId);
+        for (const action of schedules) {
+            const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
+            if (cancelRes.isFail()) {
+                // Silently ignore errors - this is non-critical cleanup.
+                // The entry was deleted successfully, cancelling scheduled actions is best-effort.
+            }
+        }
+    }
+
+    private async listSchedules(modelId: string, entryId: string) {
+        const actionsResult = await this.listScheduledActions.execute({
+            limit: 10000,
+            where: {
+                namespace: `Cms/Entry/${modelId}`,
+                targetId_startsWith: `${entryId}#`
+            }
+        });
+
+        return actionsResult.value.items;
+    }
+}
+
+export const CancelScheduledActionOnEntryDeleteHandler =
+    EntryAfterDeleteHandler.createImplementation({
+        implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,
+        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+    });

packages/api-headless-cms-scheduler/src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteHandler.ts

@@ -1,15 +1,18 @@
 import { EntryAfterPublishHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
-import { CancelScheduledEntryActionUseCase } from "../CancelScheduledEntryAction/index.js";
+import { ListScheduledActionsUseCase, CancelScheduledActionUseCase } from "@webiny/api-scheduler";
 
 /**
- * Cancels scheduled actions when an entry is manually published
+ * Cancels scheduled "publish" when an entry is manually published
  *
- * When a user manually publishes an entry, any scheduled publish/unpublish
- * actions for that entry should be cancelled since the manual action
+ * When a user manually publishes an entry, any scheduled publish
+ * action for that entry should be canceled since the manual action
  * takes precedence.
  */
 class CancelScheduledActionOnPublishHandlerImpl implements EntryAfterPublishHandler.Interface {
-    constructor(private cancelScheduledEntryAction: CancelScheduledEntryActionUseCase.Interface) {}
+    constructor(
+        private listScheduledActions: ListScheduledActionsUseCase.Interface,
+        private cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface
+    ) {}
 
     async handle(event: EntryAfterPublishHandler.Event): Promise<void> {
         const { entry, model } = event.payload;
@@ -19,19 +22,27 @@ class CancelScheduledActionOnPublishHandlerImpl implements EntryAfterPublishHand
             return;
         }
 
-        try {
-            await this.cancelScheduledEntryAction.execute({
-                modelId: model.modelId,
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: `Cms/Entry/${model.modelId}`,
+                actionType: "Publish",
                 targetId: entry.id
-            });
-        } catch {
-            // Silently ignore errors - this is non-critical cleanup
-            // The entry was published successfully, cancelling scheduled actions is best-effort
+            }
+        });
+
+        const actions = actionsResult.value.items;
+
+        for (const action of actions) {
+            const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
+            if (cancelRes.isFail()) {
+                // Silently ignore errors - this is non-critical cleanup.
+                // Even if a schedule runs on an already published action, nothing bad will happen.
+            }
         }
     }
 }
 
 export const CancelScheduledActionOnPublishHandler = EntryAfterPublishHandler.createImplementation({
     implementation: CancelScheduledActionOnPublishHandlerImpl,
-    dependencies: [CancelScheduledEntryActionUseCase]
+    dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
 });

packages/api-headless-cms-scheduler/src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishHandler.ts

@@ -0,0 +1,48 @@
+import { EntryAfterDeleteHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
+
+/**
+ * Cancels scheduled actions when an entry revision is deleted
+ *
+ * When a user deletes an entry revision, any scheduled publish/unpublish
+ * action for that revision should be canceled since the revision
+ * no longer exists.
+ */
+class CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteHandler.Interface {
+    constructor(
+        private listScheduledActions: ListScheduledActionsUseCase.Interface,
+        private cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface
+    ) {}
+
+    async handle(event: EntryAfterDeleteHandler.Event): Promise<void> {
+        const { entry, model } = event.payload;
+
+        // Skip private models
+        if (model.isPrivate) {
+            return;
+        }
+
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: `Cms/Entry/${model.modelId}`,
+                targetId: entry.id
+            }
+        });
+
+        const actions = actionsResult.value.items;
+
+        for (const action of actions) {
+            const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
+            if (cancelRes.isFail()) {
+                // Silently ignore errors - this is non-critical cleanup.
+                // Entry was deleted successfully, cancelling scheduled actions is best-effort.
+            }
+        }
+    }
+}
+
+export const CancelScheduledActionOnRevisionDeleteHandler =
+    EntryAfterDeleteHandler.createImplementation({
+        implementation: CancelScheduledActionOnDeleteHandlerImpl,
+        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+    });

packages/api-headless-cms-scheduler/src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteHandler.ts

@@ -1,15 +1,18 @@
 import { EntryAfterUnpublishHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
-import { CancelScheduledEntryActionUseCase } from "../CancelScheduledEntryAction/index.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
 
 /**
- * Cancels scheduled actions when an entry is manually unpublished
+ * Cancels scheduled action when an entry is manually unpublished
  *
- * When a user manually unpublishes an entry, any scheduled publish/unpublish
- * actions for that entry should be cancelled since the manual action
+ * When a user manually unpublishes an entry revision, any scheduled unpublish
+ * action for that revision should be canceled since the manual action
  * takes precedence.
  */
 class CancelScheduledActionOnUnpublishHandlerImpl implements EntryAfterUnpublishHandler.Interface {
-    constructor(private cancelScheduledEntryAction: CancelScheduledEntryActionUseCase.Interface) {}
+    constructor(
+        private listScheduledActions: ListScheduledActionsUseCase.Interface,
+        private cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface
+    ) {}
 
     async handle(event: EntryAfterUnpublishHandler.Event): Promise<void> {
         const { entry, model } = event.payload;
@@ -19,20 +22,28 @@ class CancelScheduledActionOnUnpublishHandlerImpl implements EntryAfterUnpublish
             return;
         }
 
-        try {
-            await this.cancelScheduledEntryAction.execute({
-                modelId: model.modelId,
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: `Cms/Entry/${model.modelId}`,
+                actionType: "Unpublish",
                 targetId: entry.id
-            });
-        } catch {
-            // Silently ignore errors - this is non-critical cleanup
-            // The entry was unpublished successfully, cancelling scheduled actions is best-effort
+            }
+        });
+
+        const actions = actionsResult.value.items;
+
+        for (const action of actions) {
+            const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
+            if (cancelRes.isFail()) {
+                // Silently ignore errors - this is non-critical cleanup.
+                // Entry was unpublished successfully, cancelling scheduled actions is best-effort.
+            }
         }
     }
 }
 
 export const CancelScheduledActionOnUnpublishHandler =
     EntryAfterUnpublishHandler.createImplementation({
         implementation: CancelScheduledActionOnUnpublishHandlerImpl,
-        dependencies: [CancelScheduledEntryActionUseCase]
+        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
     });

packages/api-headless-cms-scheduler/src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishHandler.ts

@@ -1,7 +1,8 @@
 import { createFeature } from "@webiny/feature/api";
 import { CancelScheduledActionOnPublishHandler } from "./CancelScheduledActionOnPublishHandler.js";
 import { CancelScheduledActionOnUnpublishHandler } from "./CancelScheduledActionOnUnpublishHandler.js";
-import { CancelScheduledActionOnDeleteHandler } from "./CancelScheduledActionOnDeleteHandler.js";
+import { CancelScheduledActionOnEntryDeleteHandler } from "./CancelScheduledActionOnEntryDeleteHandler.js";
+import { CancelScheduledActionOnRevisionDeleteHandler } from "./CancelScheduledActionOnRevisionDeleteHandler.js";
 
 /**
  * CancelScheduledActionOnEntryChange Feature
@@ -15,6 +16,7 @@ export const CancelScheduledActionOnEntryChangeFeature = createFeature({
     register(container) {
         container.register(CancelScheduledActionOnPublishHandler);
         container.register(CancelScheduledActionOnUnpublishHandler);
-        container.register(CancelScheduledActionOnDeleteHandler);
+        container.register(CancelScheduledActionOnEntryDeleteHandler);
+        container.register(CancelScheduledActionOnRevisionDeleteHandler);
     }
 });

packages/api-headless-cms-scheduler/src/features/CancelScheduledActionOnEntryChange/feature.ts

@@ -1,43 +1,23 @@
 import { Result } from "@webiny/feature/api";
-import { ListScheduledActionsUseCase } from "@webiny/api-scheduler/features/ListScheduledActions";
 import { CancelScheduledActionUseCase } from "@webiny/api-scheduler/features/CancelScheduledAction";
 import { CancelScheduledEntryActionUseCase as UseCaseAbstraction } from "./abstractions.js";
 
 /**
  * Cancels a scheduled CMS entry action
  */
 class CancelScheduledEntryActionUseCaseImpl implements UseCaseAbstraction.Interface {
-    constructor(
-        private listScheduledActions: ListScheduledActionsUseCase.Interface,
-        private cancelScheduledAction: CancelScheduledActionUseCase.Interface
-    ) {}
+    constructor(private cancelScheduledAction: CancelScheduledActionUseCase.Interface) {}
 
-    async execute(
-        input: UseCaseAbstraction.Input
-    ): Promise<Result<void, UseCaseAbstraction.Error>> {
-        const namespace = `Cms/Entry/${input.modelId}`;
-
-        const actionsResult = await this.listScheduledActions.execute({
-            where: {
-                namespace,
-                targetId: input.targetId
-            }
-        });
-
-        const actions = actionsResult.value.items;
-
-        for (const action of actions) {
-            const cancelRes = await this.cancelScheduledAction.execute(action.id);
-            if (cancelRes.isFail()) {
-                return Result.fail(cancelRes.error);
-            }
+    async execute(scheduleId: string): Promise<Result<void, UseCaseAbstraction.Error>> {
+        const cancelRes = await this.cancelScheduledAction.execute(scheduleId);
+        if (cancelRes.isFail()) {
+            return Result.fail(cancelRes.error);
         }
-
         return Result.ok();
     }
 }
 
 export const CancelScheduledEntryActionUseCase = UseCaseAbstraction.createImplementation({
     implementation: CancelScheduledEntryActionUseCaseImpl,
-    dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+    dependencies: [CancelScheduledActionUseCase]
 });

packages/api-headless-cms-scheduler/src/features/CancelScheduledEntryAction/CancelScheduledEntryActionUseCase.ts

@@ -12,11 +12,6 @@ import {
  * This is a convenience use case for canceling scheduled CMS entry actions.
  */
 
-export interface ICancelScheduledEntryActionInput {
-    modelId: string;
-    targetId: string;
-}
-
 export interface ICancelScheduledEntryActionErrors {
     notFound: ScheduledActionNotFoundError;
     persistence: ScheduledActionPersistenceError;
@@ -27,16 +22,13 @@ type CancelScheduledEntryActionError =
     ICancelScheduledEntryActionErrors[keyof ICancelScheduledEntryActionErrors];
 
 export interface ICancelScheduledEntryActionUseCase {
-    execute(
-        input: ICancelScheduledEntryActionInput
-    ): Promise<Result<void, CancelScheduledEntryActionError>>;
+    execute(scheduleId: string): Promise<Result<void, CancelScheduledEntryActionError>>;
 }
 
 export const CancelScheduledEntryActionUseCase =
     createAbstraction<ICancelScheduledEntryActionUseCase>("CancelScheduledEntryActionUseCase");
 
 export namespace CancelScheduledEntryActionUseCase {
     export type Interface = ICancelScheduledEntryActionUseCase;
-    export type Input = ICancelScheduledEntryActionInput;
     export type Error = CancelScheduledEntryActionError;
 }