@webiny/api-website-builder-scheduler 0.0.0-unstable.81ae05e56b

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-website-builder-scheduler
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const WEBSITE_BUILDER_NAMESPACE = "WebsiteBuilder/Type/";
+export declare const SCHEDULED_ACTION_TYPE_PAGE: "page";
+export declare const SCHEDULED_ACTION_TYPE_REDIRECT: "redirect";
+export declare const SCHEDULED_ACTION_TYPES: readonly ["page", "redirect"];

package/constants.js

@@ -0,0 +1,6 @@
+export const WEBSITE_BUILDER_NAMESPACE = "WebsiteBuilder/Type/";
+export const SCHEDULED_ACTION_TYPE_PAGE = "page";
+export const SCHEDULED_ACTION_TYPE_REDIRECT = "redirect";
+export const SCHEDULED_ACTION_TYPES = [SCHEDULED_ACTION_TYPE_PAGE, SCHEDULED_ACTION_TYPE_REDIRECT];
+
+//# sourceMappingURL=constants.js.map

package/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WEBSITE_BUILDER_NAMESPACE","SCHEDULED_ACTION_TYPE_PAGE","SCHEDULED_ACTION_TYPE_REDIRECT","SCHEDULED_ACTION_TYPES"],"sources":["constants.ts"],"sourcesContent":["export const WEBSITE_BUILDER_NAMESPACE = \"WebsiteBuilder/Type/\";\n\nexport const SCHEDULED_ACTION_TYPE_PAGE = \"page\" as const;\nexport const SCHEDULED_ACTION_TYPE_REDIRECT = \"redirect\" as const;\n\nexport const SCHEDULED_ACTION_TYPES = [\n    SCHEDULED_ACTION_TYPE_PAGE,\n    SCHEDULED_ACTION_TYPE_REDIRECT\n] as const;\n"],"mappings":"AAAA,OAAO,MAAMA,yBAAyB,GAAG,sBAAsB;AAE/D,OAAO,MAAMC,0BAA0B,GAAG,MAAe;AACzD,OAAO,MAAMC,8BAA8B,GAAG,UAAmB;AAEjE,OAAO,MAAMC,sBAAsB,GAAG,CAClCF,0BAA0B,EAC1BC,8BAA8B,CACxB","ignoreList":[]}

package/context.d.ts

@@ -0,0 +1,2 @@
+import { ContextPlugin } from "@webiny/api";
+export declare const createWebsiteBuilderScheduleContext: () => ContextPlugin<import("@webiny/api/types").Context>;

package/context.js

@@ -0,0 +1,29 @@
+import { ContextPlugin } from "@webiny/api";
+import { CancelScheduledActionOnChangeFeature } from "./features/CancelScheduledActionOnChange/feature.js";
+import { PageNamespaceHandler } from "./features/NamespaceHandler/PageNamespaceHandler.js";
+import { RedirectNamespaceHandler } from "./features/NamespaceHandler/RedirectNamespaceHandler.js";
+import { PublishPageActionHandler } from "./features/PublishActionHandler/PublishPageActionHandler.js";
+import { PublishRedirectActionHandler } from "./features/PublishActionHandler/PublishRedirectActionHandler.js";
+import { UnpublishPageActionHandler } from "./features/UnpublishActionHandler/UnpublishPageActionHandler.js";
+import { UnpublishRedirectActionHandler } from "./features/UnpublishActionHandler/UnpublishRedirectActionHandler.js";
+import { SchedulePublishPageUseCase } from "./features/SchedulePublishPageUseCase/SchedulePublishPageUseCase.js";
+import { ScheduleUnpublishPageUseCase } from "./features/ScheduleUnpublishPageUseCase/ScheduleUnpublishPageUseCase.js";
+import { SchedulePublishRedirectUseCase } from "./features/SchedulePublishRedirectUseCase/SchedulePublishRedirectUseCase.js";
+import { ScheduleUnpublishRedirectUseCase } from "./features/ScheduleUnpublishRedirectUseCase/ScheduleUnpublishRedirectUseCase.js";
+export const createWebsiteBuilderScheduleContext = () => {
+  return new ContextPlugin(async context => {
+    context.container.register(PageNamespaceHandler);
+    context.container.register(RedirectNamespaceHandler);
+    context.container.register(PublishPageActionHandler);
+    context.container.register(PublishRedirectActionHandler);
+    context.container.register(UnpublishPageActionHandler);
+    context.container.register(UnpublishRedirectActionHandler);
+    context.container.register(SchedulePublishPageUseCase);
+    context.container.register(ScheduleUnpublishPageUseCase);
+    context.container.register(SchedulePublishRedirectUseCase);
+    context.container.register(ScheduleUnpublishRedirectUseCase);
+    CancelScheduledActionOnChangeFeature.register(context.container);
+  });
+};
+
+//# sourceMappingURL=context.js.map

package/context.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ContextPlugin","CancelScheduledActionOnChangeFeature","PageNamespaceHandler","RedirectNamespaceHandler","PublishPageActionHandler","PublishRedirectActionHandler","UnpublishPageActionHandler","UnpublishRedirectActionHandler","SchedulePublishPageUseCase","ScheduleUnpublishPageUseCase","SchedulePublishRedirectUseCase","ScheduleUnpublishRedirectUseCase","createWebsiteBuilderScheduleContext","context","container","register"],"sources":["context.ts"],"sourcesContent":["import { ContextPlugin } from \"@webiny/api\";\nimport { CancelScheduledActionOnChangeFeature } from \"~/features/CancelScheduledActionOnChange/feature.js\";\nimport { PageNamespaceHandler } from \"~/features/NamespaceHandler/PageNamespaceHandler.js\";\nimport { RedirectNamespaceHandler } from \"~/features/NamespaceHandler/RedirectNamespaceHandler.js\";\nimport { PublishPageActionHandler } from \"~/features/PublishActionHandler/PublishPageActionHandler.js\";\nimport { PublishRedirectActionHandler } from \"~/features/PublishActionHandler/PublishRedirectActionHandler.js\";\nimport { UnpublishPageActionHandler } from \"~/features/UnpublishActionHandler/UnpublishPageActionHandler.js\";\nimport { UnpublishRedirectActionHandler } from \"~/features/UnpublishActionHandler/UnpublishRedirectActionHandler.js\";\nimport { SchedulePublishPageUseCase } from \"~/features/SchedulePublishPageUseCase/SchedulePublishPageUseCase.js\";\nimport { ScheduleUnpublishPageUseCase } from \"~/features/ScheduleUnpublishPageUseCase/ScheduleUnpublishPageUseCase.js\";\nimport { SchedulePublishRedirectUseCase } from \"~/features/SchedulePublishRedirectUseCase/SchedulePublishRedirectUseCase.js\";\nimport { ScheduleUnpublishRedirectUseCase } from \"~/features/ScheduleUnpublishRedirectUseCase/ScheduleUnpublishRedirectUseCase.js\";\n\nexport const createWebsiteBuilderScheduleContext = () => {\n    return new ContextPlugin(async context => {\n        context.container.register(PageNamespaceHandler);\n        context.container.register(RedirectNamespaceHandler);\n        context.container.register(PublishPageActionHandler);\n        context.container.register(PublishRedirectActionHandler);\n        context.container.register(UnpublishPageActionHandler);\n        context.container.register(UnpublishRedirectActionHandler);\n        context.container.register(SchedulePublishPageUseCase);\n        context.container.register(ScheduleUnpublishPageUseCase);\n        context.container.register(SchedulePublishRedirectUseCase);\n        context.container.register(ScheduleUnpublishRedirectUseCase);\n\n        CancelScheduledActionOnChangeFeature.register(context.container);\n    });\n};\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,aAAa;AAC3C,SAASC,oCAAoC;AAC7C,SAASC,oBAAoB;AAC7B,SAASC,wBAAwB;AACjC,SAASC,wBAAwB;AACjC,SAASC,4BAA4B;AACrC,SAASC,0BAA0B;AACnC,SAASC,8BAA8B;AACvC,SAASC,0BAA0B;AACnC,SAASC,4BAA4B;AACrC,SAASC,8BAA8B;AACvC,SAASC,gCAAgC;AAEzC,OAAO,MAAMC,mCAAmC,GAAGA,CAAA,KAAM;EACrD,OAAO,IAAIZ,aAAa,CAAC,MAAMa,OAAO,IAAI;IACtCA,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACb,oBAAoB,CAAC;IAChDW,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACZ,wBAAwB,CAAC;IACpDU,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACX,wBAAwB,CAAC;IACpDS,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACV,4BAA4B,CAAC;IACxDQ,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACT,0BAA0B,CAAC;IACtDO,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACR,8BAA8B,CAAC;IAC1DM,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACP,0BAA0B,CAAC;IACtDK,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACN,4BAA4B,CAAC;IACxDI,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACL,8BAA8B,CAAC;IAC1DG,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACJ,gCAAgC,CAAC;IAE5DV,oCAAoC,CAACc,QAAQ,CAACF,OAAO,CAACC,SAAS,CAAC;EACpE,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

package/exports/api/website-builder/scheduler.d.ts

@@ -0,0 +1,4 @@
+export { SchedulePublishPageUseCase } from "../../../features/SchedulePublishPageUseCase/abstractions.js";
+export { ScheduleUnpublishPageUseCase } from "../../../features/ScheduleUnpublishPageUseCase/abstractions.js";
+export { SchedulePublishRedirectUseCase } from "../../../features/SchedulePublishRedirectUseCase/abstractions.js";
+export { ScheduleUnpublishRedirectUseCase } from "../../../features/ScheduleUnpublishRedirectUseCase/abstractions.js";

package/exports/api/website-builder/scheduler.js

@@ -0,0 +1,6 @@
+export { SchedulePublishPageUseCase } from "../../../features/SchedulePublishPageUseCase/abstractions.js";
+export { ScheduleUnpublishPageUseCase } from "../../../features/ScheduleUnpublishPageUseCase/abstractions.js";
+export { SchedulePublishRedirectUseCase } from "../../../features/SchedulePublishRedirectUseCase/abstractions.js";
+export { ScheduleUnpublishRedirectUseCase } from "../../../features/ScheduleUnpublishRedirectUseCase/abstractions.js";
+
+//# sourceMappingURL=scheduler.js.map

package/exports/api/website-builder/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SchedulePublishPageUseCase","ScheduleUnpublishPageUseCase","SchedulePublishRedirectUseCase","ScheduleUnpublishRedirectUseCase"],"sources":["scheduler.ts"],"sourcesContent":["export { SchedulePublishPageUseCase } from \"~/features/SchedulePublishPageUseCase/abstractions.js\";\nexport { ScheduleUnpublishPageUseCase } from \"~/features/ScheduleUnpublishPageUseCase/abstractions.js\";\nexport { SchedulePublishRedirectUseCase } from \"~/features/SchedulePublishRedirectUseCase/abstractions.js\";\nexport { ScheduleUnpublishRedirectUseCase } from \"~/features/ScheduleUnpublishRedirectUseCase/abstractions.js\";\n"],"mappings":"AAAA,SAASA,0BAA0B;AACnC,SAASC,4BAA4B;AACrC,SAASC,8BAA8B;AACvC,SAASC,gCAAgC","ignoreList":[]}

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageDeleteEventHandler.d.ts

@@ -0,0 +1,18 @@
+import { PageAfterDeleteEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+/**
+ * Cancels scheduled actions when a page is deleted.
+ *
+ * When a user deletes a page revision, any scheduled publish/unpublish
+ * actions for that revision should be canceled since the page no longer exists.
+ */
+declare class CancelScheduledActionOnPageDeleteHandlerImpl implements PageAfterDeleteEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    handle(event: PageAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnPageDeleteEventHandler: typeof CancelScheduledActionOnPageDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/DeletePage/abstractions").PageAfterDeletePayload>>>;
+};
+export {};

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageDeleteEventHandler.js

@@ -0,0 +1,43 @@
+import { PageAfterDeleteEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+import { SCHEDULED_ACTION_TYPE_PAGE } from "../../constants.js";
+
+/**
+ * Cancels scheduled actions when a page is deleted.
+ *
+ * When a user deletes a page revision, any scheduled publish/unpublish
+ * actions for that revision should be canceled since the page no longer exists.
+ */
+class CancelScheduledActionOnPageDeleteHandlerImpl {
+  constructor(listScheduledActions, cancelScheduledAction) {
+    this.listScheduledActions = listScheduledActions;
+    this.cancelScheduledAction = cancelScheduledAction;
+  }
+  async handle(event) {
+    const {
+      page
+    } = event.payload;
+    const actionsResult = await this.listScheduledActions.execute({
+      limit: 10000,
+      where: {
+        namespace: createNamespace(SCHEDULED_ACTION_TYPE_PAGE),
+        targetId: page.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.
+        // The page was deleted successfully, cancelling scheduled actions is best-effort.
+      }
+    }
+  }
+}
+export const CancelScheduledActionOnPageDeleteEventHandler = PageAfterDeleteEventHandler.createImplementation({
+  implementation: CancelScheduledActionOnPageDeleteHandlerImpl,
+  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+});
+
+//# sourceMappingURL=CancelScheduledActionOnPageDeleteEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PageAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","SCHEDULED_ACTION_TYPE_PAGE","CancelScheduledActionOnPageDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","page","payload","actionsResult","execute","limit","where","namespace","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnPageDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnPageDeleteEventHandler.ts"],"sourcesContent":["import { PageAfterDeleteEventHandler } from \"@webiny/api-website-builder/exports/api/website-builder/page.js\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\nimport { SCHEDULED_ACTION_TYPE_PAGE } from \"~/constants.js\";\n\n/**\n * Cancels scheduled actions when a page is deleted.\n *\n * When a user deletes a page revision, any scheduled publish/unpublish\n * actions for that revision should be canceled since the page no longer exists.\n */\nclass CancelScheduledActionOnPageDeleteHandlerImpl\n    implements PageAfterDeleteEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: PageAfterDeleteEventHandler.Event): Promise<void> {\n        const { page } = event.payload;\n\n        const actionsResult = await this.listScheduledActions.execute({\n            limit: 10000,\n            where: {\n                namespace: createNamespace(SCHEDULED_ACTION_TYPE_PAGE),\n                targetId: page.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                // The page was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPageDeleteEventHandler =\n    PageAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnPageDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,2BAA2B,QAAQ,iEAAiE;AAC7G,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;AACxB,SAASC,0BAA0B;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,4CAA4C,CAElD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAAwC,EAAiB;IAClE,MAAM;MAAEC;IAAK,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE9B,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACN,oBAAoB,CAACO,OAAO,CAAC;MAC1DC,KAAK,EAAE,KAAK;MACZC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACC,0BAA0B,CAAC;QACtDc,QAAQ,EAAEP,IAAI,CAACQ;MACnB;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,CAAChB,qBAAqB,CAACM,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,6CAA6C,GACtD1B,2BAA2B,CAAC2B,oBAAoB,CAAC;EAC7CC,cAAc,EAAEvB,4CAA4C;EAC5DwB,YAAY,EAAE,CAAC3B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPagePublishEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { PageAfterPublishEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+/**
+ * Cancels scheduled "publish" when a page is manually published.
+ *
+ * When a user manually publishes a page, any scheduled publish
+ * action for that page should be canceled since the manual action
+ * takes precedence.
+ */
+declare class CancelScheduledActionOnPublishEventHandlerImpl implements PageAfterPublishEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    handle(event: PageAfterPublishEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnPagePublishEventHandler: typeof CancelScheduledActionOnPublishEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/PublishPage/abstractions").PageAfterPublishPayload>>>;
+};
+export {};

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPagePublishEventHandler.js

@@ -0,0 +1,44 @@
+import { PageAfterPublishEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+import { SCHEDULED_ACTION_TYPE_PAGE } from "../../constants.js";
+
+/**
+ * Cancels scheduled "publish" when a page is manually published.
+ *
+ * When a user manually publishes a page, any scheduled publish
+ * action for that page should be canceled since the manual action
+ * takes precedence.
+ */
+class CancelScheduledActionOnPublishEventHandlerImpl {
+  constructor(listScheduledActions, cancelScheduledAction) {
+    this.listScheduledActions = listScheduledActions;
+    this.cancelScheduledAction = cancelScheduledAction;
+  }
+  async handle(event) {
+    const {
+      page
+    } = event.payload;
+    const actionsResult = await this.listScheduledActions.execute({
+      where: {
+        namespace: createNamespace(SCHEDULED_ACTION_TYPE_PAGE),
+        actionType: ScheduledActionTypePublish,
+        targetId: page.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 page, nothing bad will happen.
+      }
+    }
+  }
+}
+export const CancelScheduledActionOnPagePublishEventHandler = PageAfterPublishEventHandler.createImplementation({
+  implementation: CancelScheduledActionOnPublishEventHandlerImpl,
+  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+});
+
+//# sourceMappingURL=CancelScheduledActionOnPagePublishEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPagePublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PageAfterPublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","ScheduledActionTypePublish","createNamespace","SCHEDULED_ACTION_TYPE_PAGE","CancelScheduledActionOnPublishEventHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","page","payload","actionsResult","execute","where","namespace","actionType","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnPagePublishEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnPagePublishEventHandler.ts"],"sourcesContent":["import { PageAfterPublishEventHandler } from \"@webiny/api-website-builder/exports/api/website-builder/page.js\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\nimport { SCHEDULED_ACTION_TYPE_PAGE } from \"~/constants.js\";\n\n/**\n * Cancels scheduled \"publish\" when a page is manually published.\n *\n * When a user manually publishes a page, any scheduled publish\n * action for that page should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnPublishEventHandlerImpl\n    implements PageAfterPublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: PageAfterPublishEventHandler.Event): Promise<void> {\n        const { page } = event.payload;\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(SCHEDULED_ACTION_TYPE_PAGE),\n                actionType: ScheduledActionTypePublish,\n                targetId: page.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 page, nothing bad will happen.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPagePublishEventHandler =\n    PageAfterPublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnPublishEventHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,iEAAiE;AAC9G,SACIC,4BAA4B,EAC5BC,2BAA2B,EAC3BC,0BAA0B,QACvB,gDAAgD;AACvD,SAASC,eAAe;AACxB,SAASC,0BAA0B;;AAEnC;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,KAAyC,EAAiB;IACnE,MAAM;MAAEC;IAAK,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE9B,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACN,oBAAoB,CAACO,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEb,eAAe,CAACC,0BAA0B,CAAC;QACtDa,UAAU,EAAEf,0BAA0B;QACtCgB,QAAQ,EAAEP,IAAI,CAACQ;MACnB;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,CAAChB,qBAAqB,CAACM,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,8CAA8C,GACvD3B,4BAA4B,CAAC4B,oBAAoB,CAAC;EAC9CC,cAAc,EAAEvB,8CAA8C;EAC9DwB,YAAY,EAAE,CAAC5B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageUnpublishEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { PageAfterUnpublishEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+/**
+ * Cancels scheduled "unpublish" when a page is manually unpublished.
+ *
+ * When a user manually unpublishes a page, any scheduled unpublish
+ * action for that page should be canceled since the manual action
+ * takes precedence.
+ */
+declare class CancelScheduledActionOnUnpublishHandlerImpl implements PageAfterUnpublishEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    handle(event: PageAfterUnpublishEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnPageUnpublishEventHandler: typeof CancelScheduledActionOnUnpublishHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/UnpublishPage/abstractions").PageAfterUnpublishPayload>>>;
+};
+export {};

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageUnpublishEventHandler.js

@@ -0,0 +1,44 @@
+import { PageAfterUnpublishEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+import { SCHEDULED_ACTION_TYPE_PAGE } from "../../constants.js";
+
+/**
+ * Cancels scheduled "unpublish" when a page is manually unpublished.
+ *
+ * When a user manually unpublishes a page, any scheduled unpublish
+ * action for that page should be canceled since the manual action
+ * takes precedence.
+ */
+class CancelScheduledActionOnUnpublishHandlerImpl {
+  constructor(listScheduledActions, cancelScheduledAction) {
+    this.listScheduledActions = listScheduledActions;
+    this.cancelScheduledAction = cancelScheduledAction;
+  }
+  async handle(event) {
+    const {
+      page
+    } = event.payload;
+    const actionsResult = await this.listScheduledActions.execute({
+      where: {
+        namespace: createNamespace(SCHEDULED_ACTION_TYPE_PAGE),
+        actionType: ScheduledActionTypeUnpublish,
+        targetId: page.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.
+        // Page was unpublished successfully, cancelling scheduled actions is best-effort.
+      }
+    }
+  }
+}
+export const CancelScheduledActionOnPageUnpublishEventHandler = PageAfterUnpublishEventHandler.createImplementation({
+  implementation: CancelScheduledActionOnUnpublishHandlerImpl,
+  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+});
+
+//# sourceMappingURL=CancelScheduledActionOnPageUnpublishEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageUnpublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PageAfterUnpublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","ScheduledActionTypeUnpublish","createNamespace","SCHEDULED_ACTION_TYPE_PAGE","CancelScheduledActionOnUnpublishHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","page","payload","actionsResult","execute","where","namespace","actionType","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnPageUnpublishEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnPageUnpublishEventHandler.ts"],"sourcesContent":["import { PageAfterUnpublishEventHandler } from \"@webiny/api-website-builder/exports/api/website-builder/page.js\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\nimport { SCHEDULED_ACTION_TYPE_PAGE } from \"~/constants.js\";\n\n/**\n * Cancels scheduled \"unpublish\" when a page is manually unpublished.\n *\n * When a user manually unpublishes a page, any scheduled unpublish\n * action for that page should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnUnpublishHandlerImpl\n    implements PageAfterUnpublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: PageAfterUnpublishEventHandler.Event): Promise<void> {\n        const { page } = event.payload;\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(SCHEDULED_ACTION_TYPE_PAGE),\n                actionType: ScheduledActionTypeUnpublish,\n                targetId: page.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                // Page was unpublished successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPageUnpublishEventHandler =\n    PageAfterUnpublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnUnpublishHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,8BAA8B,QAAQ,iEAAiE;AAChH,SACIC,4BAA4B,EAC5BC,2BAA2B,EAC3BC,4BAA4B,QACzB,gDAAgD;AACvD,SAASC,eAAe;AACxB,SAASC,0BAA0B;;AAEnC;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,KAA2C,EAAiB;IACrE,MAAM;MAAEC;IAAK,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE9B,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACN,oBAAoB,CAACO,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEb,eAAe,CAACC,0BAA0B,CAAC;QACtDa,UAAU,EAAEf,4BAA4B;QACxCgB,QAAQ,EAAEP,IAAI,CAACQ;MACnB;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,CAAChB,qBAAqB,CAACM,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,gDAAgD,GACzD3B,8BAA8B,CAAC4B,oBAAoB,CAAC;EAChDC,cAAc,EAAEvB,2CAA2C;EAC3DwB,YAAY,EAAE,CAAC5B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnRedirectDeleteEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { RedirectAfterDeleteEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/redirect.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+/**
+ * Cancels scheduled actions when a redirect is deleted.
+ *
+ * When a user deletes a redirect, any scheduled publish/unpublish
+ * actions for that redirect should be canceled since the redirect
+ * no longer exists.
+ */
+declare class CancelScheduledActionOnRedirectDeleteHandlerImpl implements RedirectAfterDeleteEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface);
+    handle(event: RedirectAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnRedirectDeleteEventHandler: typeof CancelScheduledActionOnRedirectDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("@webiny/api-website-builder/features/redirects/DeleteRedirect/abstractions").RedirectAfterDeletePayload>>>;
+};
+export {};

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnRedirectDeleteEventHandler.js

@@ -0,0 +1,43 @@
+import { RedirectAfterDeleteEventHandler } from "@webiny/api-website-builder/exports/api/website-builder/redirect.js";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+import { SCHEDULED_ACTION_TYPE_REDIRECT } from "../../constants.js";
+
+/**
+ * Cancels scheduled actions when a redirect is deleted.
+ *
+ * When a user deletes a redirect, any scheduled publish/unpublish
+ * actions for that redirect should be canceled since the redirect
+ * no longer exists.
+ */
+class CancelScheduledActionOnRedirectDeleteHandlerImpl {
+  constructor(listScheduledActions, cancelScheduledAction) {
+    this.listScheduledActions = listScheduledActions;
+    this.cancelScheduledAction = cancelScheduledAction;
+  }
+  async handle(event) {
+    const {
+      redirect
+    } = event.payload;
+    const actionsResult = await this.listScheduledActions.execute({
+      where: {
+        namespace: createNamespace(SCHEDULED_ACTION_TYPE_REDIRECT),
+        targetId: redirect.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.
+        // The redirect was deleted successfully, cancelling scheduled actions is best-effort.
+      }
+    }
+  }
+}
+export const CancelScheduledActionOnRedirectDeleteEventHandler = RedirectAfterDeleteEventHandler.createImplementation({
+  implementation: CancelScheduledActionOnRedirectDeleteHandlerImpl,
+  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+});
+
+//# sourceMappingURL=CancelScheduledActionOnRedirectDeleteEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnRedirectDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RedirectAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","SCHEDULED_ACTION_TYPE_REDIRECT","CancelScheduledActionOnRedirectDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","redirect","payload","actionsResult","execute","where","namespace","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnRedirectDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnRedirectDeleteEventHandler.ts"],"sourcesContent":["import { RedirectAfterDeleteEventHandler } from \"@webiny/api-website-builder/exports/api/website-builder/redirect.js\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\nimport { SCHEDULED_ACTION_TYPE_REDIRECT } from \"~/constants.js\";\n\n/**\n * Cancels scheduled actions when a redirect is deleted.\n *\n * When a user deletes a redirect, any scheduled publish/unpublish\n * actions for that redirect should be canceled since the redirect\n * no longer exists.\n */\nclass CancelScheduledActionOnRedirectDeleteHandlerImpl\n    implements RedirectAfterDeleteEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: RedirectAfterDeleteEventHandler.Event): Promise<void> {\n        const { redirect } = event.payload;\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(SCHEDULED_ACTION_TYPE_REDIRECT),\n                targetId: redirect.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                // The redirect was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnRedirectDeleteEventHandler =\n    RedirectAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnRedirectDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,+BAA+B,QAAQ,qEAAqE;AACrH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;AACxB,SAASC,8BAA8B;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,gDAAgD,CAEtD;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;IAAS,CAAC,GAAGD,KAAK,CAACE,OAAO;IAElC,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACN,oBAAoB,CAACO,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEb,eAAe,CAACC,8BAA8B,CAAC;QAC1Da,QAAQ,EAAEN,QAAQ,CAACO;MACvB;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,CAACf,qBAAqB,CAACM,OAAO,CAACQ,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,iDAAiD,GAC1DzB,+BAA+B,CAAC0B,oBAAoB,CAAC;EACjDC,cAAc,EAAEtB,gDAAgD;EAChEuB,YAAY,EAAE,CAAC1B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnChange/feature.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CancelScheduledActionOnChange Feature
+ *
+ * Automatically cancels scheduled actions when pages or redirects are manually
+ * published, unpublished, or deleted. This ensures scheduled actions
+ * don't execute after a user has already performed the action manually.
+ */
+export declare const CancelScheduledActionOnChangeFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/CancelScheduledActionOnChange/feature.js

@@ -0,0 +1,24 @@
+import { createFeature } from "@webiny/feature/api";
+import { CancelScheduledActionOnPagePublishEventHandler } from "./CancelScheduledActionOnPagePublishEventHandler.js";
+import { CancelScheduledActionOnPageUnpublishEventHandler } from "./CancelScheduledActionOnPageUnpublishEventHandler.js";
+import { CancelScheduledActionOnPageDeleteEventHandler } from "./CancelScheduledActionOnPageDeleteEventHandler.js";
+import { CancelScheduledActionOnRedirectDeleteEventHandler } from "./CancelScheduledActionOnRedirectDeleteEventHandler.js";
+
+/**
+ * CancelScheduledActionOnChange Feature
+ *
+ * Automatically cancels scheduled actions when pages or redirects are manually
+ * published, unpublished, or deleted. This ensures scheduled actions
+ * don't execute after a user has already performed the action manually.
+ */
+export const CancelScheduledActionOnChangeFeature = createFeature({
+  name: "CancelScheduledActionOnChange",
+  register(container) {
+    container.register(CancelScheduledActionOnPagePublishEventHandler);
+    container.register(CancelScheduledActionOnPageUnpublishEventHandler);
+    container.register(CancelScheduledActionOnPageDeleteEventHandler);
+    container.register(CancelScheduledActionOnRedirectDeleteEventHandler);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/CancelScheduledActionOnChange/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CancelScheduledActionOnPagePublishEventHandler","CancelScheduledActionOnPageUnpublishEventHandler","CancelScheduledActionOnPageDeleteEventHandler","CancelScheduledActionOnRedirectDeleteEventHandler","CancelScheduledActionOnChangeFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CancelScheduledActionOnPagePublishEventHandler } from \"./CancelScheduledActionOnPagePublishEventHandler.js\";\nimport { CancelScheduledActionOnPageUnpublishEventHandler } from \"./CancelScheduledActionOnPageUnpublishEventHandler.js\";\nimport { CancelScheduledActionOnPageDeleteEventHandler } from \"./CancelScheduledActionOnPageDeleteEventHandler.js\";\nimport { CancelScheduledActionOnRedirectDeleteEventHandler } from \"./CancelScheduledActionOnRedirectDeleteEventHandler.js\";\n\n/**\n * CancelScheduledActionOnChange Feature\n *\n * Automatically cancels scheduled actions when pages or redirects are manually\n * published, unpublished, or deleted. This ensures scheduled actions\n * don't execute after a user has already performed the action manually.\n */\nexport const CancelScheduledActionOnChangeFeature = createFeature({\n    name: \"CancelScheduledActionOnChange\",\n    register(container) {\n        container.register(CancelScheduledActionOnPagePublishEventHandler);\n        container.register(CancelScheduledActionOnPageUnpublishEventHandler);\n        container.register(CancelScheduledActionOnPageDeleteEventHandler);\n        container.register(CancelScheduledActionOnRedirectDeleteEventHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,8CAA8C;AACvD,SAASC,gDAAgD;AACzD,SAASC,6CAA6C;AACtD,SAASC,iDAAiD;;AAE1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,oCAAoC,GAAGL,aAAa,CAAC;EAC9DM,IAAI,EAAE,+BAA+B;EACrCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACN,8CAA8C,CAAC;IAClEO,SAAS,CAACD,QAAQ,CAACL,gDAAgD,CAAC;IACpEM,SAAS,CAACD,QAAQ,CAACJ,6CAA6C,CAAC;IACjEK,SAAS,CAACD,QAAQ,CAACH,iDAAiD,CAAC;EACzE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/NamespaceHandler/PageNamespaceHandler.d.ts

@@ -0,0 +1,14 @@
+import { NamespaceHandler as NamespaceHandlerAbstraction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { IScheduledActionPayload } from "../../types.js";
+import { GetPageByIdUseCase } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+declare class PageNamespaceHandlerImpl implements NamespaceHandlerAbstraction.Interface<GenericRecord> {
+    private getPageByIdUseCase;
+    constructor(getPageByIdUseCase: GetPageByIdUseCase.Interface);
+    canHandle(namespace: string): boolean;
+    execute(params: NamespaceHandlerAbstraction.Params): NamespaceHandlerAbstraction.Response<IScheduledActionPayload>;
+}
+export declare const PageNamespaceHandler: typeof PageNamespaceHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/features/NamespaceHandler/abstractions").INamespaceHandler<GenericRecord>>;
+};
+export {};

package/features/NamespaceHandler/PageNamespaceHandler.js

@@ -0,0 +1,38 @@
+import { NamespaceHandler as NamespaceHandlerAbstraction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { extractModelIdFromNamespace } from "../../utils/namespace.js";
+import { Result } from "@webiny/feature/exports/api.js";
+import { SCHEDULED_ACTION_TYPE_PAGE } from "../../constants.js";
+import { GetPageByIdUseCase } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+class PageNamespaceHandlerImpl {
+  constructor(getPageByIdUseCase) {
+    this.getPageByIdUseCase = getPageByIdUseCase;
+  }
+  canHandle(namespace) {
+    const type = extractModelIdFromNamespace(namespace);
+    return type === SCHEDULED_ACTION_TYPE_PAGE;
+  }
+  async execute(params) {
+    const type = extractModelIdFromNamespace(params.namespace);
+    const pageResult = await this.getPageByIdUseCase.execute(params.targetId);
+    if (pageResult.isFail()) {
+      return Result.fail(pageResult.error);
+    }
+    const page = pageResult.value;
+    const title = page.properties.title || "Unknown page title";
+    return Result.ok({
+      namespace: params.namespace,
+      title,
+      type,
+      actionType: params.actionType,
+      targetId: params.targetId,
+      scheduleId: params.scheduleId,
+      immediately: params.immediately || false
+    });
+  }
+}
+export const PageNamespaceHandler = NamespaceHandlerAbstraction.createImplementation({
+  implementation: PageNamespaceHandlerImpl,
+  dependencies: [GetPageByIdUseCase]
+});
+
+//# sourceMappingURL=PageNamespaceHandler.js.map

package/features/NamespaceHandler/PageNamespaceHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NamespaceHandler","NamespaceHandlerAbstraction","extractModelIdFromNamespace","Result","SCHEDULED_ACTION_TYPE_PAGE","GetPageByIdUseCase","PageNamespaceHandlerImpl","constructor","getPageByIdUseCase","canHandle","namespace","type","execute","params","pageResult","targetId","isFail","fail","error","page","value","title","properties","ok","actionType","scheduleId","immediately","PageNamespaceHandler","createImplementation","implementation","dependencies"],"sources":["PageNamespaceHandler.ts"],"sourcesContent":["import { NamespaceHandler as NamespaceHandlerAbstraction } from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { extractModelIdFromNamespace } from \"~/utils/namespace.js\";\nimport { Result } from \"@webiny/feature/exports/api.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { SCHEDULED_ACTION_TYPE_PAGE } from \"~/constants.js\";\nimport type { IScheduledActionPayload } from \"~/types.js\";\nimport { GetPageByIdUseCase } from \"@webiny/api-website-builder/exports/api/website-builder/page.js\";\n\nclass PageNamespaceHandlerImpl implements NamespaceHandlerAbstraction.Interface<GenericRecord> {\n    public constructor(private getPageByIdUseCase: GetPageByIdUseCase.Interface) {}\n\n    public canHandle(namespace: string): boolean {\n        const type = extractModelIdFromNamespace(namespace);\n        return type === SCHEDULED_ACTION_TYPE_PAGE;\n    }\n\n    public async execute(\n        params: NamespaceHandlerAbstraction.Params\n    ): NamespaceHandlerAbstraction.Response<IScheduledActionPayload> {\n        const type = extractModelIdFromNamespace(params.namespace)!;\n\n        const pageResult = await this.getPageByIdUseCase.execute(params.targetId);\n        if (pageResult.isFail()) {\n            return Result.fail(pageResult.error as any);\n        }\n        const page = pageResult.value;\n\n        const title = page.properties.title || \"Unknown page title\";\n\n        return Result.ok({\n            namespace: params.namespace,\n            title,\n            type,\n            actionType: params.actionType,\n            targetId: params.targetId,\n            scheduleId: params.scheduleId,\n            immediately: params.immediately || false\n        });\n    }\n}\n\nexport const PageNamespaceHandler = NamespaceHandlerAbstraction.createImplementation({\n    implementation: PageNamespaceHandlerImpl,\n    dependencies: [GetPageByIdUseCase]\n});\n"],"mappings":"AAAA,SAASA,gBAAgB,IAAIC,2BAA2B,QAAQ,gDAAgD;AAChH,SAASC,2BAA2B;AACpC,SAASC,MAAM,QAAQ,gCAAgC;AAEvD,SAASC,0BAA0B;AAEnC,SAASC,kBAAkB,QAAQ,iEAAiE;AAEpG,MAAMC,wBAAwB,CAAiE;EACpFC,WAAWA,CAASC,kBAAgD,EAAE;IAAA,KAAlDA,kBAAgD,GAAhDA,kBAAgD;EAAG;EAEvEC,SAASA,CAACC,SAAiB,EAAW;IACzC,MAAMC,IAAI,GAAGT,2BAA2B,CAACQ,SAAS,CAAC;IACnD,OAAOC,IAAI,KAAKP,0BAA0B;EAC9C;EAEA,MAAaQ,OAAOA,CAChBC,MAA0C,EACmB;IAC7D,MAAMF,IAAI,GAAGT,2BAA2B,CAACW,MAAM,CAACH,SAAS,CAAE;IAE3D,MAAMI,UAAU,GAAG,MAAM,IAAI,CAACN,kBAAkB,CAACI,OAAO,CAACC,MAAM,CAACE,QAAQ,CAAC;IACzE,IAAID,UAAU,CAACE,MAAM,CAAC,CAAC,EAAE;MACrB,OAAOb,MAAM,CAACc,IAAI,CAACH,UAAU,CAACI,KAAY,CAAC;IAC/C;IACA,MAAMC,IAAI,GAAGL,UAAU,CAACM,KAAK;IAE7B,MAAMC,KAAK,GAAGF,IAAI,CAACG,UAAU,CAACD,KAAK,IAAI,oBAAoB;IAE3D,OAAOlB,MAAM,CAACoB,EAAE,CAAC;MACbb,SAAS,EAAEG,MAAM,CAACH,SAAS;MAC3BW,KAAK;MACLV,IAAI;MACJa,UAAU,EAAEX,MAAM,CAACW,UAAU;MAC7BT,QAAQ,EAAEF,MAAM,CAACE,QAAQ;MACzBU,UAAU,EAAEZ,MAAM,CAACY,UAAU;MAC7BC,WAAW,EAAEb,MAAM,CAACa,WAAW,IAAI;IACvC,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMC,oBAAoB,GAAG1B,2BAA2B,CAAC2B,oBAAoB,CAAC;EACjFC,cAAc,EAAEvB,wBAAwB;EACxCwB,YAAY,EAAE,CAACzB,kBAAkB;AACrC,CAAC,CAAC","ignoreList":[]}

package/features/NamespaceHandler/RedirectNamespaceHandler.d.ts

@@ -0,0 +1,14 @@
+import { NamespaceHandler as NamespaceHandlerAbstraction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { IScheduledActionPayload } from "../../types.js";
+import { GetRedirectByIdUseCase } from "@webiny/api-website-builder/exports/api/website-builder/redirect.js";
+declare class RedirectNamespaceHandlerImpl implements NamespaceHandlerAbstraction.Interface<GenericRecord> {
+    private getRedirectByIdUseCase;
+    constructor(getRedirectByIdUseCase: GetRedirectByIdUseCase.Interface);
+    canHandle(namespace: string): boolean;
+    execute(params: NamespaceHandlerAbstraction.Params): NamespaceHandlerAbstraction.Response<IScheduledActionPayload>;
+}
+export declare const RedirectNamespaceHandler: typeof RedirectNamespaceHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/features/NamespaceHandler/abstractions").INamespaceHandler<GenericRecord>>;
+};
+export {};

package/features/NamespaceHandler/RedirectNamespaceHandler.js

@@ -0,0 +1,38 @@
+import { NamespaceHandler as NamespaceHandlerAbstraction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { extractModelIdFromNamespace } from "../../utils/namespace.js";
+import { Result } from "@webiny/feature/exports/api.js";
+import { SCHEDULED_ACTION_TYPE_REDIRECT } from "../../constants.js";
+import { GetRedirectByIdUseCase } from "@webiny/api-website-builder/exports/api/website-builder/redirect.js";
+class RedirectNamespaceHandlerImpl {
+  constructor(getRedirectByIdUseCase) {
+    this.getRedirectByIdUseCase = getRedirectByIdUseCase;
+  }
+  canHandle(namespace) {
+    const type = extractModelIdFromNamespace(namespace);
+    return type === SCHEDULED_ACTION_TYPE_REDIRECT;
+  }
+  async execute(params) {
+    const type = extractModelIdFromNamespace(params.namespace);
+    const redirectResult = await this.getRedirectByIdUseCase.execute(params.targetId);
+    if (redirectResult.isFail()) {
+      return Result.fail(redirectResult.error);
+    }
+    const redirect = redirectResult.value;
+    const title = redirect.redirectFrom || "Unknown redirect title";
+    return Result.ok({
+      namespace: params.namespace,
+      title,
+      type,
+      actionType: params.actionType,
+      targetId: params.targetId,
+      scheduleId: params.scheduleId,
+      immediately: params.immediately || false
+    });
+  }
+}
+export const RedirectNamespaceHandler = NamespaceHandlerAbstraction.createImplementation({
+  implementation: RedirectNamespaceHandlerImpl,
+  dependencies: [GetRedirectByIdUseCase]
+});
+
+//# sourceMappingURL=RedirectNamespaceHandler.js.map

package/features/NamespaceHandler/RedirectNamespaceHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NamespaceHandler","NamespaceHandlerAbstraction","extractModelIdFromNamespace","Result","SCHEDULED_ACTION_TYPE_REDIRECT","GetRedirectByIdUseCase","RedirectNamespaceHandlerImpl","constructor","getRedirectByIdUseCase","canHandle","namespace","type","execute","params","redirectResult","targetId","isFail","fail","error","redirect","value","title","redirectFrom","ok","actionType","scheduleId","immediately","RedirectNamespaceHandler","createImplementation","implementation","dependencies"],"sources":["RedirectNamespaceHandler.ts"],"sourcesContent":["import { NamespaceHandler as NamespaceHandlerAbstraction } from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { extractModelIdFromNamespace } from \"~/utils/namespace.js\";\nimport { Result } from \"@webiny/feature/exports/api.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { SCHEDULED_ACTION_TYPE_REDIRECT } from \"~/constants.js\";\nimport type { IScheduledActionPayload } from \"~/types.js\";\nimport { GetRedirectByIdUseCase } from \"@webiny/api-website-builder/exports/api/website-builder/redirect.js\";\n\nclass RedirectNamespaceHandlerImpl implements NamespaceHandlerAbstraction.Interface<GenericRecord> {\n    public constructor(private getRedirectByIdUseCase: GetRedirectByIdUseCase.Interface) {}\n\n    public canHandle(namespace: string): boolean {\n        const type = extractModelIdFromNamespace(namespace);\n\n        return type === SCHEDULED_ACTION_TYPE_REDIRECT;\n    }\n\n    public async execute(\n        params: NamespaceHandlerAbstraction.Params\n    ): NamespaceHandlerAbstraction.Response<IScheduledActionPayload> {\n        const type = extractModelIdFromNamespace(params.namespace)!;\n\n        const redirectResult = await this.getRedirectByIdUseCase.execute(params.targetId);\n        if (redirectResult.isFail()) {\n            return Result.fail(redirectResult.error as any);\n        }\n        const redirect = redirectResult.value;\n\n        const title = redirect.redirectFrom || \"Unknown redirect title\";\n\n        return Result.ok({\n            namespace: params.namespace,\n            title,\n            type,\n            actionType: params.actionType,\n            targetId: params.targetId,\n            scheduleId: params.scheduleId,\n            immediately: params.immediately || false\n        });\n    }\n}\n\nexport const RedirectNamespaceHandler = NamespaceHandlerAbstraction.createImplementation({\n    implementation: RedirectNamespaceHandlerImpl,\n    dependencies: [GetRedirectByIdUseCase]\n});\n"],"mappings":"AAAA,SAASA,gBAAgB,IAAIC,2BAA2B,QAAQ,gDAAgD;AAChH,SAASC,2BAA2B;AACpC,SAASC,MAAM,QAAQ,gCAAgC;AAEvD,SAASC,8BAA8B;AAEvC,SAASC,sBAAsB,QAAQ,qEAAqE;AAE5G,MAAMC,4BAA4B,CAAiE;EACxFC,WAAWA,CAASC,sBAAwD,EAAE;IAAA,KAA1DA,sBAAwD,GAAxDA,sBAAwD;EAAG;EAE/EC,SAASA,CAACC,SAAiB,EAAW;IACzC,MAAMC,IAAI,GAAGT,2BAA2B,CAACQ,SAAS,CAAC;IAEnD,OAAOC,IAAI,KAAKP,8BAA8B;EAClD;EAEA,MAAaQ,OAAOA,CAChBC,MAA0C,EACmB;IAC7D,MAAMF,IAAI,GAAGT,2BAA2B,CAACW,MAAM,CAACH,SAAS,CAAE;IAE3D,MAAMI,cAAc,GAAG,MAAM,IAAI,CAACN,sBAAsB,CAACI,OAAO,CAACC,MAAM,CAACE,QAAQ,CAAC;IACjF,IAAID,cAAc,CAACE,MAAM,CAAC,CAAC,EAAE;MACzB,OAAOb,MAAM,CAACc,IAAI,CAACH,cAAc,CAACI,KAAY,CAAC;IACnD;IACA,MAAMC,QAAQ,GAAGL,cAAc,CAACM,KAAK;IAErC,MAAMC,KAAK,GAAGF,QAAQ,CAACG,YAAY,IAAI,wBAAwB;IAE/D,OAAOnB,MAAM,CAACoB,EAAE,CAAC;MACbb,SAAS,EAAEG,MAAM,CAACH,SAAS;MAC3BW,KAAK;MACLV,IAAI;MACJa,UAAU,EAAEX,MAAM,CAACW,UAAU;MAC7BT,QAAQ,EAAEF,MAAM,CAACE,QAAQ;MACzBU,UAAU,EAAEZ,MAAM,CAACY,UAAU;MAC7BC,WAAW,EAAEb,MAAM,CAACa,WAAW,IAAI;IACvC,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMC,wBAAwB,GAAG1B,2BAA2B,CAAC2B,oBAAoB,CAAC;EACrFC,cAAc,EAAEvB,4BAA4B;EAC5CwB,YAAY,EAAE,CAACzB,sBAAsB;AACzC,CAAC,CAAC","ignoreList":[]}