@webiny/api-headless-cms-scheduler 0.0.0-unstable.c27f4d8a31 → 0.0.0-unstable.d0f34a8194

package/CmsSchedulerFeature.d.ts

@@ -0,0 +1,4 @@
+export declare const CmsSchedulerFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/CmsSchedulerFeature.js

@@ -0,0 +1,23 @@
+import { createFeature } from "@webiny/feature/api";
+import { CancelScheduledActionOnEntryChangeFeature } from "./features/CancelScheduledActionOnEntryChange/feature.js";
+import { CmsSchedulerPermissions } from "./features/permissions/CmsSchedulerPermissions.js";
+import { NamespaceHandler } from "./features/NamespaceHandler/NamespaceHandler.js";
+import { PublishEntryActionHandler } from "./features/PublishActionHandler/PublishEntryActionHandler.js";
+import { UnpublishEntryActionHandler } from "./features/UnpublishActionHandler/UnpublishEntryActionHandler.js";
+import { SchedulePublishEntryUseCase } from "./features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.js";
+import { ScheduleUnpublishEntryUseCase } from "./features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.js";
+const CmsSchedulerFeature = createFeature({
+    name: "CmsScheduler",
+    register (container) {
+        container.register(NamespaceHandler);
+        container.register(PublishEntryActionHandler);
+        container.register(UnpublishEntryActionHandler);
+        container.register(SchedulePublishEntryUseCase);
+        container.register(ScheduleUnpublishEntryUseCase);
+        CancelScheduledActionOnEntryChangeFeature.register(container);
+        container.register(CmsSchedulerPermissions);
+    }
+});
+export { CmsSchedulerFeature };
+
+//# sourceMappingURL=CmsSchedulerFeature.js.map

package/CmsSchedulerFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CmsSchedulerFeature.js","sources":["../src/CmsSchedulerFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CancelScheduledActionOnEntryChangeFeature } from \"~/features/CancelScheduledActionOnEntryChange/feature.js\";\nimport { CmsSchedulerPermissions } from \"~/features/permissions/CmsSchedulerPermissions.js\";\nimport { NamespaceHandler } from \"~/features/NamespaceHandler/NamespaceHandler.js\";\nimport { PublishEntryActionHandler } from \"~/features/PublishActionHandler/PublishEntryActionHandler.js\";\nimport { UnpublishEntryActionHandler } from \"~/features/UnpublishActionHandler/UnpublishEntryActionHandler.js\";\nimport { SchedulePublishEntryUseCase } from \"~/features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.js\";\nimport { ScheduleUnpublishEntryUseCase } from \"~/features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.js\";\n\nexport const CmsSchedulerFeature = createFeature({\n    name: \"CmsScheduler\",\n    register(container) {\n        // Pure DI registration (was a request-time ContextPlugin — none of it needs ctx/post-auth).\n        container.register(NamespaceHandler);\n        container.register(PublishEntryActionHandler);\n        container.register(UnpublishEntryActionHandler);\n        container.register(SchedulePublishEntryUseCase);\n        container.register(ScheduleUnpublishEntryUseCase);\n\n        CancelScheduledActionOnEntryChangeFeature.register(container);\n        container.register(CmsSchedulerPermissions);\n    }\n});\n"],"names":["CmsSchedulerFeature","createFeature","container","NamespaceHandler","PublishEntryActionHandler","UnpublishEntryActionHandler","SchedulePublishEntryUseCase","ScheduleUnpublishEntryUseCase","CancelScheduledActionOnEntryChangeFeature","CmsSchedulerPermissions"],"mappings":";;;;;;;;AASO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QAEnBC,0CAA0C,QAAQ,CAACN;QACnDA,UAAU,QAAQ,CAACO;IACvB;AACJ"}

package/exports/api/cms/scheduler.js

@@ -1,4 +1,2 @@
 export { SchedulePublishEntryUseCase } from "../../../features/SchedulePublishEntryUseCase/abstractions.js";
 export { ScheduleUnpublishEntryUseCase } from "../../../features/ScheduleUnpublishEntryUseCase/abstractions.js";
-
-//# sourceMappingURL=scheduler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.d.ts

@@ -1,5 +1,6 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
 import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 /**
  * Cancels scheduled actions when an entry is deleted
  *
@@ -10,11 +11,12 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
 declare class CancelScheduledActionOnEntryDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
     private listScheduledActions;
     private cancelScheduledAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
     handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
     private listSchedules;
 }
 export declare const CancelScheduledActionOnEntryDeleteEventHandler: typeof CancelScheduledActionOnEntryDeleteHandlerImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js

@@ -1,54 +1,49 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
 import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 import { createNamespace } from "../../utils/namespace.js";
-
-/**
- * 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 {
-  constructor(listScheduledActions, cancelScheduledAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledAction = cancelScheduledAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const schedules = await this.listSchedules(model.modelId, entry.entryId);
+        for (const action of schedules){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-    const schedules = await this.listSchedules(model.modelId, entry.entryId);
-    for (const action of schedules) {
-      const cancelRes = await this.cancelScheduledAction.execute(action);
-      if (cancelRes.isFail()) {
-        // Silently ignore errors - this is non-critical cleanup.
-        // The entry was deleted successfully, cancelling scheduled actions is best-effort.
-      }
+    async listSchedules(modelId, entryId) {
+        const actionsResult = await this.listScheduledActions.execute({
+            limit: 10000,
+            where: {
+                namespace: createNamespace({
+                    modelId
+                }),
+                targetId_startsWith: `${entryId}#`
+            }
+        });
+        if (actionsResult.isFail()) {
+            this.logger.error({
+                error: actionsResult.error
+            }, "Could not list scheduled actions to cancel.");
+            return [];
+        }
+        return actionsResult.value.items;
     }
-  }
-  async listSchedules(modelId, entryId) {
-    const actionsResult = await this.listScheduledActions.execute({
-      limit: 10000,
-      where: {
-        namespace: createNamespace({
-          modelId
-        }),
-        targetId_startsWith: `${entryId}#`
-      }
-    });
-    return actionsResult.value.items;
-  }
 }
-export const CancelScheduledActionOnEntryDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnEntryDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
 });
+export { CancelScheduledActionOnEntryDeleteEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnEntryDeleteEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","CancelScheduledActionOnEntryDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","schedules","listSchedules","modelId","entryId","action","cancelRes","execute","isFail","actionsResult","limit","where","namespace","targetId_startsWith","value","items","CancelScheduledActionOnEntryDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnEntryDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry is deleted\n *\n * When a user deletes an entry, any scheduled publish/unpublish\n * actions for all of its revisions should be canceled since the entry\n * no longer exists.\n */\nclass CancelScheduledActionOnEntryDeleteHandlerImpl\n    implements EntryAfterDeleteEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const schedules = await this.listSchedules(model.modelId, entry.entryId);\n        for (const action of schedules) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // The entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n\n    private async listSchedules(modelId: string, entryId: string) {\n        const actionsResult = await this.listScheduledActions.execute({\n            limit: 10000,\n            where: {\n                namespace: createNamespace({ modelId }),\n                targetId_startsWith: `${entryId}#`\n            }\n        });\n\n        return actionsResult.value.items;\n    }\n}\n\nexport const CancelScheduledActionOnEntryDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,mEAAmE;AAChH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,6CAA6C,CAEnD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACC,aAAa,CAACJ,KAAK,CAACK,OAAO,EAAEN,KAAK,CAACO,OAAO,CAAC;IACxE,KAAK,MAAMC,MAAM,IAAIJ,SAAS,EAAE;MAC5B,MAAMK,SAAS,GAAG,MAAM,IAAI,CAACZ,qBAAqB,CAACa,OAAO,CAACF,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACE,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;EAEA,MAAcN,aAAaA,CAACC,OAAe,EAAEC,OAAe,EAAE;IAC1D,MAAMK,aAAa,GAAG,MAAM,IAAI,CAAChB,oBAAoB,CAACc,OAAO,CAAC;MAC1DG,KAAK,EAAE,KAAK;MACZC,KAAK,EAAE;QACHC,SAAS,EAAEtB,eAAe,CAAC;UAAEa;QAAQ,CAAC,CAAC;QACvCU,mBAAmB,EAAE,GAAGT,OAAO;MACnC;IACJ,CAAC,CAAC;IAEF,OAAOK,aAAa,CAACK,KAAK,CAACC,KAAK;EACpC;AACJ;AAEA,OAAO,MAAMC,8CAA8C,GACvD7B,4BAA4B,CAAC8B,oBAAoB,CAAC;EAC9CC,cAAc,EAAE3B,6CAA6C;EAC7D4B,YAAY,EAAE,CAAC9B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry is deleted\n *\n * When a user deletes an entry, any scheduled publish/unpublish\n * actions for all of its revisions should be canceled since the entry\n * no longer exists.\n */\nclass CancelScheduledActionOnEntryDeleteHandlerImpl\n    implements EntryAfterDeleteEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const schedules = await this.listSchedules(model.modelId, entry.entryId);\n        for (const action of schedules) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // The entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n\n    private async listSchedules(modelId: string, entryId: string) {\n        const actionsResult = await this.listScheduledActions.execute({\n            limit: 10000,\n            where: {\n                namespace: createNamespace({ modelId }),\n                targetId_startsWith: `${entryId}#`\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return [];\n        }\n\n        return actionsResult.value.items;\n    }\n}\n\nexport const CancelScheduledActionOnEntryDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnEntryDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","schedules","action","cancelRes","modelId","entryId","actionsResult","createNamespace","CancelScheduledActionOnEntryDeleteEventHandler","EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAeA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAACD,MAAM,OAAO,EAAED,MAAM,OAAO;QACvE,KAAK,MAAMG,UAAUD,UAAW;YAC5B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;IAEA,MAAc,cAAcC,OAAe,EAAEC,OAAe,EAAE;QAC1D,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;YACP,OAAO;gBACH,WAAWC,gBAAgB;oBAAEH;gBAAQ;gBACrC,qBAAqB,GAAGC,QAAQ,CAAC,CAAC;YACtC;QACJ;QAEA,IAAIC,cAAc,MAAM,IAAI;YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,OAAOA,cAAc,KAAK;YAAC,GAC7B;YAEJ,OAAO,EAAE;QACb;QAEA,OAAOA,cAAc,KAAK,CAAC,KAAK;IACpC;AACJ;AAEO,MAAME,iDACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBf;IAChB,cAAc;QAACgB;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.d.ts

@@ -1,5 +1,6 @@
 import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
 import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 /**
  * Cancels scheduled "publish" when an entry is manually published
  *
@@ -10,10 +11,11 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
 declare class CancelScheduledActionOnPublishEventHandlerImpl implements EntryAfterPublishEventHandler.Interface {
     private listScheduledActions;
     private cancelScheduledAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
     handle(event: EntryAfterPublishEventHandler.Event): Promise<void>;
 }
 export declare const CancelScheduledActionOnPublishEventHandler: typeof CancelScheduledActionOnPublishEventHandlerImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/PublishEntry/events").EntryAfterPublishEvent>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/PublishEntry/events").EntryAfterPublishEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js

@@ -1,49 +1,41 @@
 import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 import { createNamespace } from "../../utils/namespace.js";
-
-/**
- * Cancels scheduled "publish" when an entry is manually published
- *
- * When a user manually publishes an entry, any scheduled publish
- * action for that entry should be canceled since the manual action
- * takes precedence.
- */
 class CancelScheduledActionOnPublishEventHandlerImpl {
-  constructor(listScheduledActions, cancelScheduledAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledAction = cancelScheduledAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
     }
-    const actionsResult = await this.listScheduledActions.execute({
-      where: {
-        namespace: createNamespace(model),
-        actionType: "publish",
-        targetId: entry.id
-      }
-    });
-    const actions = actionsResult.value.items;
-    for (const action of actions) {
-      const cancelRes = await this.cancelScheduledAction.execute(action);
-      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.
-      }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                actionType: ScheduledActionTypePublish,
+                targetId: entry.id
+            }
+        });
+        if (actionsResult.isFail()) return void this.logger.error({
+            error: actionsResult.error
+        }, "Could not list scheduled actions to cancel.");
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-  }
 }
-export const CancelScheduledActionOnPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnPublishEventHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnPublishEventHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
 });
+export { CancelScheduledActionOnPublishEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnPublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterPublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","CancelScheduledActionOnPublishEventHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","actionType","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnPublishEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnPublishEventHandler.ts"],"sourcesContent":["import { EntryAfterPublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled \"publish\" when an entry is manually published\n *\n * When a user manually publishes an entry, any scheduled publish\n * action for that entry should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnPublishEventHandlerImpl\n    implements EntryAfterPublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterPublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: \"publish\",\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Even if a schedule runs on an already published action, nothing bad will happen.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPublishEventHandler =\n    EntryAfterPublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnPublishEventHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,6BAA6B,QAAQ,oEAAoE;AAClH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,8CAA8C,CAEpD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAA0C,EAAiB;IACpE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACR,oBAAoB,CAACS,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACQ,KAAK,CAAC;QACjCO,UAAU,EAAE,SAAS;QACrBC,QAAQ,EAAET,KAAK,CAACU;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGP,aAAa,CAACQ,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAAClB,qBAAqB,CAACQ,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,0CAA0C,GACnD3B,6BAA6B,CAAC4B,oBAAoB,CAAC;EAC/CC,cAAc,EAAEzB,8CAA8C;EAC9D0B,YAAY,EAAE,CAAC5B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.ts"],"sourcesContent":["import { EntryAfterPublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled \"publish\" when an entry is manually published\n *\n * When a user manually publishes an entry, any scheduled publish\n * action for that entry should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnPublishEventHandlerImpl\n    implements EntryAfterPublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterPublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: ScheduledActionTypePublish,\n                targetId: entry.id\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return;\n        }\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Even if a schedule runs on an already published action, nothing bad will happen.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPublishEventHandler =\n    EntryAfterPublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnPublishEventHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnPublishEventHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","actionsResult","createNamespace","ScheduledActionTypePublish","actions","action","cancelRes","CancelScheduledActionOnPublishEventHandler","EntryAfterPublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAgBA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAA0C,EAAiB;QACpE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBF;gBAC3B,YAAYG;gBACZ,UAAUJ,MAAM,EAAE;YACtB;QACJ;QAEA,IAAIE,cAAc,MAAM,IAAI,YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;YAAE,OAAOA,cAAc,KAAK;QAAC,GAC7B;QAKR,MAAMG,UAAUH,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMI,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,6CACTC,8BAA8B,oBAAoB,CAAC;IAC/C,gBAAgBd;IAChB,cAAc;QAACe;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.d.ts

@@ -1,5 +1,6 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
 import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 /**
  * Cancels scheduled actions when an entry revision is deleted
  *
@@ -10,10 +11,11 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
 declare class CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
     private listScheduledActions;
     private cancelScheduledAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
     handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
 }
 export declare const CancelScheduledActionOnRevisionDeleteEventHandler: typeof CancelScheduledActionOnDeleteHandlerImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js

@@ -1,48 +1,40 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
 import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 import { createNamespace } from "../../utils/namespace.js";
-
-/**
- * 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 {
-  constructor(listScheduledActions, cancelScheduledAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledAction = cancelScheduledAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
     }
-    const actionsResult = await this.listScheduledActions.execute({
-      where: {
-        namespace: createNamespace(model),
-        targetId: entry.id
-      }
-    });
-    const actions = actionsResult.value.items;
-    for (const action of actions) {
-      const cancelRes = await this.cancelScheduledAction.execute(action);
-      if (cancelRes.isFail()) {
-        // Silently ignore errors - this is non-critical cleanup.
-        // Entry was deleted successfully, cancelling scheduled actions is best-effort.
-      }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                targetId: entry.id
+            }
+        });
+        if (actionsResult.isFail()) return void this.logger.error({
+            error: actionsResult.error
+        }, "Could not list scheduled actions to cancel.");
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-  }
 }
-export const CancelScheduledActionOnRevisionDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnDeleteHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnRevisionDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
 });
+export { CancelScheduledActionOnRevisionDeleteEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnRevisionDeleteEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","CancelScheduledActionOnDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnRevisionDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnRevisionDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry revision is deleted\n *\n * When a user deletes an entry revision, any scheduled publish/unpublish\n * action for that revision should be canceled since the revision\n * no longer exists.\n */\nclass CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnRevisionDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,mEAAmE;AAChH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACR,oBAAoB,CAACS,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACQ,KAAK,CAAC;QACjCO,QAAQ,EAAER,KAAK,CAACS;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGN,aAAa,CAACO,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAACjB,qBAAqB,CAACQ,OAAO,CAACQ,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,iDAAiD,GAC1D1B,4BAA4B,CAAC2B,oBAAoB,CAAC;EAC9CC,cAAc,EAAExB,wCAAwC;EACxDyB,YAAY,EAAE,CAAC3B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry revision is deleted\n *\n * When a user deletes an entry revision, any scheduled publish/unpublish\n * action for that revision should be canceled since the revision\n * no longer exists.\n */\nclass CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                targetId: entry.id\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return;\n        }\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnRevisionDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","actionsResult","createNamespace","actions","action","cancelRes","CancelScheduledActionOnRevisionDeleteEventHandler","EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAeA,MAAMA;IACF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBF;gBAC3B,UAAUD,MAAM,EAAE;YACtB;QACJ;QAEA,IAAIE,cAAc,MAAM,IAAI,YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;YAAE,OAAOA,cAAc,KAAK;QAAC,GAC7B;QAKR,MAAME,UAAUF,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMG,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,oDACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.d.ts

@@ -1,5 +1,6 @@
 import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
 import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 /**
  * Cancels scheduled action when an entry is manually unpublished
  *
@@ -10,10 +11,11 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
 declare class CancelScheduledActionOnUnpublishHandlerImpl implements EntryAfterUnpublishEventHandler.Interface {
     private listScheduledActions;
     private cancelScheduledAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
     handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void>;
 }
 export declare const CancelScheduledActionOnUnpublishEventHandler: typeof CancelScheduledActionOnUnpublishHandlerImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events").EntryAfterUnpublishEvent>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events").EntryAfterUnpublishEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js

@@ -1,49 +1,41 @@
 import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 import { createNamespace } from "../../utils/namespace.js";
-
-/**
- * Cancels scheduled action when an entry is manually unpublished
- *
- * 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 {
-  constructor(listScheduledActions, cancelScheduledAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledAction = cancelScheduledAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
     }
-    const actionsResult = await this.listScheduledActions.execute({
-      where: {
-        namespace: createNamespace(model),
-        actionType: "unpublish",
-        targetId: entry.id
-      }
-    });
-    const actions = actionsResult.value.items;
-    for (const action of actions) {
-      const cancelRes = await this.cancelScheduledAction.execute(action);
-      if (cancelRes.isFail()) {
-        // Silently ignore errors - this is non-critical cleanup.
-        // Entry was unpublished successfully, cancelling scheduled actions is best-effort.
-      }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                actionType: ScheduledActionTypeUnpublish,
+                targetId: entry.id
+            }
+        });
+        if (actionsResult.isFail()) return void this.logger.error({
+            error: actionsResult.error
+        }, "Could not list scheduled actions to cancel.");
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-  }
 }
-export const CancelScheduledActionOnUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnUnpublishHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnUnpublishHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
 });
+export { CancelScheduledActionOnUnpublishEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnUnpublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterUnpublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","CancelScheduledActionOnUnpublishHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","actionType","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnUnpublishEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnUnpublishEventHandler.ts"],"sourcesContent":["import { EntryAfterUnpublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled action when an entry is manually unpublished\n *\n * When a user manually unpublishes an entry revision, any scheduled unpublish\n * action for that revision should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnUnpublishHandlerImpl\n    implements EntryAfterUnpublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: \"unpublish\",\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was unpublished successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnUnpublishEventHandler =\n    EntryAfterUnpublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnUnpublishHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,+BAA+B,QAAQ,sEAAsE;AACtH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,2CAA2C,CAEjD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAA4C,EAAiB;IACtE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACR,oBAAoB,CAACS,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACQ,KAAK,CAAC;QACjCO,UAAU,EAAE,WAAW;QACvBC,QAAQ,EAAET,KAAK,CAACU;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGP,aAAa,CAACQ,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAAClB,qBAAqB,CAACQ,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,4CAA4C,GACrD3B,+BAA+B,CAAC4B,oBAAoB,CAAC;EACjDC,cAAc,EAAEzB,2CAA2C;EAC3D0B,YAAY,EAAE,CAAC5B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.ts"],"sourcesContent":["import { EntryAfterUnpublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled action when an entry is manually unpublished\n *\n * When a user manually unpublishes an entry revision, any scheduled unpublish\n * action for that revision should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnUnpublishHandlerImpl\n    implements EntryAfterUnpublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: ScheduledActionTypeUnpublish,\n                targetId: entry.id\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return;\n        }\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was unpublished successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnUnpublishEventHandler =\n    EntryAfterUnpublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnUnpublishHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnUnpublishHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","actionsResult","createNamespace","ScheduledActionTypeUnpublish","actions","action","cancelRes","CancelScheduledActionOnUnpublishEventHandler","EntryAfterUnpublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAgBA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBF;gBAC3B,YAAYG;gBACZ,UAAUJ,MAAM,EAAE;YACtB;QACJ;QAEA,IAAIE,cAAc,MAAM,IAAI,YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;YAAE,OAAOA,cAAc,KAAK;QAAC,GAC7B;QAKR,MAAMG,UAAUH,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMI,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,+CACTC,gCAAgC,oBAAoB,CAAC;IACjD,gBAAgBd;IAChB,cAAc;QAACe;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/feature.d.ts

@@ -5,4 +5,7 @@
  * published, unpublished, or deleted. This ensures scheduled actions
  * don't execute after a user has already performed the action manually.
  */
-export declare const CancelScheduledActionOnEntryChangeFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;
+export declare const CancelScheduledActionOnEntryChangeFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};