@webiny/api-website-builder-scheduler 0.0.0-unstable.7be00a75a9

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,10 @@
+const WEBSITE_BUILDER_NAMESPACE = "WebsiteBuilder/Type/";
+const SCHEDULED_ACTION_TYPE_PAGE = "page";
+const SCHEDULED_ACTION_TYPE_REDIRECT = "redirect";
+const SCHEDULED_ACTION_TYPES = [
+    SCHEDULED_ACTION_TYPE_PAGE,
+    SCHEDULED_ACTION_TYPE_REDIRECT
+];
+export { SCHEDULED_ACTION_TYPES, SCHEDULED_ACTION_TYPE_PAGE, SCHEDULED_ACTION_TYPE_REDIRECT, WEBSITE_BUILDER_NAMESPACE };
+
+//# sourceMappingURL=constants.js.map

package/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../src/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"],"names":["WEBSITE_BUILDER_NAMESPACE","SCHEDULED_ACTION_TYPE_PAGE","SCHEDULED_ACTION_TYPE_REDIRECT","SCHEDULED_ACTION_TYPES"],"mappings":"AAAO,MAAMA,4BAA4B;AAElC,MAAMC,6BAA6B;AACnC,MAAMC,iCAAiC;AAEvC,MAAMC,yBAAyB;IAClCF;IACAC;CACH"}

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,28 @@
+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";
+const createWebsiteBuilderScheduleContext = ()=>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);
+    });
+export { createWebsiteBuilderScheduleContext };
+
+//# sourceMappingURL=context.js.map

package/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sources":["../src/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"],"names":["createWebsiteBuilderScheduleContext","ContextPlugin","context","PageNamespaceHandler","RedirectNamespaceHandler","PublishPageActionHandler","PublishRedirectActionHandler","UnpublishPageActionHandler","UnpublishRedirectActionHandler","SchedulePublishPageUseCase","ScheduleUnpublishPageUseCase","SchedulePublishRedirectUseCase","ScheduleUnpublishRedirectUseCase","CancelScheduledActionOnChangeFeature"],"mappings":";;;;;;;;;;;;AAaO,MAAMA,sCAAsC,IACxC,IAAIC,cAAc,OAAMC;QAC3BA,QAAQ,SAAS,CAAC,QAAQ,CAACC;QAC3BD,QAAQ,SAAS,CAAC,QAAQ,CAACE;QAC3BF,QAAQ,SAAS,CAAC,QAAQ,CAACG;QAC3BH,QAAQ,SAAS,CAAC,QAAQ,CAACI;QAC3BJ,QAAQ,SAAS,CAAC,QAAQ,CAACK;QAC3BL,QAAQ,SAAS,CAAC,QAAQ,CAACM;QAC3BN,QAAQ,SAAS,CAAC,QAAQ,CAACO;QAC3BP,QAAQ,SAAS,CAAC,QAAQ,CAACQ;QAC3BR,QAAQ,SAAS,CAAC,QAAQ,CAACS;QAC3BT,QAAQ,SAAS,CAAC,QAAQ,CAACU;QAE3BC,qCAAqC,QAAQ,CAACX,QAAQ,SAAS;IACnE"}

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,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/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,35 @@
+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";
+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);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnPageDeleteEventHandler = PageAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnPageDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
+});
+export { CancelScheduledActionOnPageDeleteEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnPageDeleteEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnChange/CancelScheduledActionOnPageDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnChange/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"],"names":["CancelScheduledActionOnPageDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","event","page","actionsResult","createNamespace","SCHEDULED_ACTION_TYPE_PAGE","actions","action","cancelRes","CancelScheduledActionOnPageDeleteEventHandler","PageAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;;AAcA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAM,OAAOC,KAAwC,EAAiB;QAClE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAE9B,MAAME,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;YACP,OAAO;gBACH,WAAWC,gBAAgBC;gBAC3B,UAAUH,KAAK,EAAE;YACrB;QACJ;QAEA,MAAMI,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,gDACTC,4BAA4B,oBAAoB,CAAC;IAC7C,gBAAgBZ;IAChB,cAAc;QAACa;QAA6BC;KAA6B;AAC7E"}

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,35 @@
+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";
+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);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnPagePublishEventHandler = PageAfterPublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnPublishEventHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
+});
+export { CancelScheduledActionOnPagePublishEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnPagePublishEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPagePublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnChange/CancelScheduledActionOnPagePublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnChange/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"],"names":["CancelScheduledActionOnPublishEventHandlerImpl","listScheduledActions","cancelScheduledAction","event","page","actionsResult","createNamespace","SCHEDULED_ACTION_TYPE_PAGE","ScheduledActionTypePublish","actions","action","cancelRes","CancelScheduledActionOnPagePublishEventHandler","PageAfterPublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;;AAgBA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAE9B,MAAME,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBC;gBAC3B,YAAYC;gBACZ,UAAUJ,KAAK,EAAE;YACrB;QACJ;QAEA,MAAMK,UAAUJ,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMK,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,iDACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;KAA6B;AAC7E"}

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,35 @@
+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";
+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);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnPageUnpublishEventHandler = PageAfterUnpublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnUnpublishHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
+});
+export { CancelScheduledActionOnPageUnpublishEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnPageUnpublishEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnPageUnpublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnChange/CancelScheduledActionOnPageUnpublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnChange/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"],"names":["CancelScheduledActionOnUnpublishHandlerImpl","listScheduledActions","cancelScheduledAction","event","page","actionsResult","createNamespace","SCHEDULED_ACTION_TYPE_PAGE","ScheduledActionTypeUnpublish","actions","action","cancelRes","CancelScheduledActionOnPageUnpublishEventHandler","PageAfterUnpublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;;AAgBA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAM,OAAOC,KAA2C,EAAiB;QACrE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAE9B,MAAME,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBC;gBAC3B,YAAYC;gBACZ,UAAUJ,KAAK,EAAE;YACrB;QACJ;QAEA,MAAMK,UAAUJ,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMK,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,mDACTC,+BAA+B,oBAAoB,CAAC;IAChD,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;KAA6B;AAC7E"}

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,34 @@
+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";
+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);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnRedirectDeleteEventHandler = RedirectAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnRedirectDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
+});
+export { CancelScheduledActionOnRedirectDeleteEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnRedirectDeleteEventHandler.js.map

package/features/CancelScheduledActionOnChange/CancelScheduledActionOnRedirectDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnChange/CancelScheduledActionOnRedirectDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnChange/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"],"names":["CancelScheduledActionOnRedirectDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","event","redirect","actionsResult","createNamespace","SCHEDULED_ACTION_TYPE_REDIRECT","actions","action","cancelRes","CancelScheduledActionOnRedirectDeleteEventHandler","RedirectAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;;AAeA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,QAAQ,EAAE,GAAGD,MAAM,OAAO;QAElC,MAAME,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBC;gBAC3B,UAAUH,SAAS,EAAE;YACzB;QACJ;QAEA,MAAMI,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,oDACTC,gCAAgC,oBAAoB,CAAC;IACjD,gBAAgBZ;IAChB,cAAc;QAACa;QAA6BC;KAA6B;AAC7E"}

package/features/CancelScheduledActionOnChange/feature.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/CancelScheduledActionOnChange/feature.js

@@ -0,0 +1,17 @@
+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";
+const CancelScheduledActionOnChangeFeature = createFeature({
+    name: "CancelScheduledActionOnChange",
+    register (container) {
+        container.register(CancelScheduledActionOnPagePublishEventHandler);
+        container.register(CancelScheduledActionOnPageUnpublishEventHandler);
+        container.register(CancelScheduledActionOnPageDeleteEventHandler);
+        container.register(CancelScheduledActionOnRedirectDeleteEventHandler);
+    }
+});
+export { CancelScheduledActionOnChangeFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/CancelScheduledActionOnChange/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnChange/feature.js","sources":["../../../src/features/CancelScheduledActionOnChange/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"],"names":["CancelScheduledActionOnChangeFeature","createFeature","container","CancelScheduledActionOnPagePublishEventHandler","CancelScheduledActionOnPageUnpublishEventHandler","CancelScheduledActionOnPageDeleteEventHandler","CancelScheduledActionOnRedirectDeleteEventHandler"],"mappings":";;;;;AAaO,MAAMA,uCAAuCC,cAAc;IAC9D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;IACvB;AACJ"}

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,39 @@
+import { NamespaceHandler } 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
+        });
+    }
+}
+const PageNamespaceHandler = NamespaceHandler.createImplementation({
+    implementation: PageNamespaceHandlerImpl,
+    dependencies: [
+        GetPageByIdUseCase
+    ]
+});
+export { PageNamespaceHandler };
+
+//# sourceMappingURL=PageNamespaceHandler.js.map

package/features/NamespaceHandler/PageNamespaceHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/NamespaceHandler/PageNamespaceHandler.js","sources":["../../../src/features/NamespaceHandler/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"],"names":["PageNamespaceHandlerImpl","getPageByIdUseCase","namespace","type","extractModelIdFromNamespace","SCHEDULED_ACTION_TYPE_PAGE","params","pageResult","Result","page","title","PageNamespaceHandler","NamespaceHandlerAbstraction","GetPageByIdUseCase"],"mappings":";;;;;AAQA,MAAMA;IACF,YAA2BC,kBAAgD,CAAE;aAAlDA,kBAAkB,GAAlBA;IAAmD;IAEvE,UAAUC,SAAiB,EAAW;QACzC,MAAMC,OAAOC,4BAA4BF;QACzC,OAAOC,SAASE;IACpB;IAEA,MAAa,QACTC,MAA0C,EACmB;QAC7D,MAAMH,OAAOC,4BAA4BE,OAAO,SAAS;QAEzD,MAAMC,aAAa,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACD,OAAO,QAAQ;QACxE,IAAIC,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAACD,WAAW,KAAK;QAEvC,MAAME,OAAOF,WAAW,KAAK;QAE7B,MAAMG,QAAQD,KAAK,UAAU,CAAC,KAAK,IAAI;QAEvC,OAAOD,OAAO,EAAE,CAAC;YACb,WAAWF,OAAO,SAAS;YAC3BI;YACAP;YACA,YAAYG,OAAO,UAAU;YAC7B,UAAUA,OAAO,QAAQ;YACzB,YAAYA,OAAO,UAAU;YAC7B,aAAaA,OAAO,WAAW,IAAI;QACvC;IACJ;AACJ;AAEO,MAAMK,uBAAuBC,iBAAAA,oBAAgD,CAAC;IACjF,gBAAgBZ;IAChB,cAAc;QAACa;KAAmB;AACtC"}

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,39 @@
+import { NamespaceHandler } 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
+        });
+    }
+}
+const RedirectNamespaceHandler = NamespaceHandler.createImplementation({
+    implementation: RedirectNamespaceHandlerImpl,
+    dependencies: [
+        GetRedirectByIdUseCase
+    ]
+});
+export { RedirectNamespaceHandler };
+
+//# sourceMappingURL=RedirectNamespaceHandler.js.map

package/features/NamespaceHandler/RedirectNamespaceHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/NamespaceHandler/RedirectNamespaceHandler.js","sources":["../../../src/features/NamespaceHandler/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"],"names":["RedirectNamespaceHandlerImpl","getRedirectByIdUseCase","namespace","type","extractModelIdFromNamespace","SCHEDULED_ACTION_TYPE_REDIRECT","params","redirectResult","Result","redirect","title","RedirectNamespaceHandler","NamespaceHandlerAbstraction","GetRedirectByIdUseCase"],"mappings":";;;;;AAQA,MAAMA;IACF,YAA2BC,sBAAwD,CAAE;aAA1DA,sBAAsB,GAAtBA;IAA2D;IAE/E,UAAUC,SAAiB,EAAW;QACzC,MAAMC,OAAOC,4BAA4BF;QAEzC,OAAOC,SAASE;IACpB;IAEA,MAAa,QACTC,MAA0C,EACmB;QAC7D,MAAMH,OAAOC,4BAA4BE,OAAO,SAAS;QAEzD,MAAMC,iBAAiB,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAACD,OAAO,QAAQ;QAChF,IAAIC,eAAe,MAAM,IACrB,OAAOC,OAAO,IAAI,CAACD,eAAe,KAAK;QAE3C,MAAME,WAAWF,eAAe,KAAK;QAErC,MAAMG,QAAQD,SAAS,YAAY,IAAI;QAEvC,OAAOD,OAAO,EAAE,CAAC;YACb,WAAWF,OAAO,SAAS;YAC3BI;YACAP;YACA,YAAYG,OAAO,UAAU;YAC7B,UAAUA,OAAO,QAAQ;YACzB,YAAYA,OAAO,UAAU;YAC7B,aAAaA,OAAO,WAAW,IAAI;QACvC;IACJ;AACJ;AAEO,MAAMK,2BAA2BC,iBAAAA,oBAAgD,CAAC;IACrF,gBAAgBZ;IAChB,cAAc;QAACa;KAAuB;AAC1C"}

package/features/PublishActionHandler/PublishPageActionHandler.d.ts

@@ -0,0 +1,16 @@
+import { ScheduledActionHandler, ScheduledActionType, type IScheduledAction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { PublishPageUseCase } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import type { IScheduledActionPayload } from "../../types.js";
+/**
+ * Handles the scheduled "publish" action for Website Builder pages.
+ */
+declare class PublishPageActionHandlerImpl implements ScheduledActionHandler.Interface {
+    private publishPageUseCase;
+    constructor(publishPageUseCase: PublishPageUseCase.Interface);
+    canHandle(namespace: string, actionType: ScheduledActionType): boolean;
+    handle(action: IScheduledAction<IScheduledActionPayload>): Promise<void>;
+}
+export declare const PublishPageActionHandler: typeof PublishPageActionHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/shared/abstractions").IScheduledActionHandler>;
+};
+export {};

package/features/PublishActionHandler/PublishPageActionHandler.js

@@ -0,0 +1,30 @@
+import { ScheduledActionHandler, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { PublishPageUseCase } from "@webiny/api-website-builder/exports/api/website-builder/page.js";
+import { extractModelIdFromNamespace } from "../../utils/namespace.js";
+import { SCHEDULED_ACTION_TYPE_PAGE } from "../../constants.js";
+class PublishPageActionHandlerImpl {
+    constructor(publishPageUseCase){
+        this.publishPageUseCase = publishPageUseCase;
+    }
+    canHandle(namespace, actionType) {
+        return extractModelIdFromNamespace(namespace) === SCHEDULED_ACTION_TYPE_PAGE && actionType === ScheduledActionTypePublish;
+    }
+    async handle(action) {
+        const result = await this.publishPageUseCase.execute({
+            id: action.targetId
+        });
+        if (result.isFail()) {
+            console.error(`Failed to publish page "${action.targetId}":`, result.error);
+            throw new Error(`Failed to publish page: ${action.targetId}`);
+        }
+    }
+}
+const PublishPageActionHandler = ScheduledActionHandler.createImplementation({
+    implementation: PublishPageActionHandlerImpl,
+    dependencies: [
+        PublishPageUseCase
+    ]
+});
+export { PublishPageActionHandler };
+
+//# sourceMappingURL=PublishPageActionHandler.js.map

package/features/PublishActionHandler/PublishPageActionHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/PublishActionHandler/PublishPageActionHandler.js","sources":["../../../src/features/PublishActionHandler/PublishPageActionHandler.ts"],"sourcesContent":["import {\n    ScheduledActionHandler,\n    ScheduledActionType,\n    type IScheduledAction,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { PublishPageUseCase } from \"@webiny/api-website-builder/exports/api/website-builder/page.js\";\nimport type { IScheduledActionPayload } from \"~/types.js\";\nimport { extractModelIdFromNamespace } from \"~/utils/namespace.js\";\nimport { SCHEDULED_ACTION_TYPE_PAGE } from \"~/constants.js\";\n\n/**\n * Handles the scheduled \"publish\" action for Website Builder pages.\n */\nclass PublishPageActionHandlerImpl implements ScheduledActionHandler.Interface {\n    constructor(private publishPageUseCase: PublishPageUseCase.Interface) {}\n\n    public canHandle(namespace: string, actionType: ScheduledActionType): boolean {\n        return (\n            extractModelIdFromNamespace(namespace) === SCHEDULED_ACTION_TYPE_PAGE &&\n            actionType === ScheduledActionTypePublish\n        );\n    }\n\n    public async handle(action: IScheduledAction<IScheduledActionPayload>): Promise<void> {\n        const result = await this.publishPageUseCase.execute({ id: action.targetId });\n        if (result.isFail()) {\n            console.error(`Failed to publish page \"${action.targetId}\":`, result.error);\n            throw new Error(`Failed to publish page: ${action.targetId}`);\n        }\n    }\n}\n\nexport const PublishPageActionHandler = ScheduledActionHandler.createImplementation({\n    implementation: PublishPageActionHandlerImpl,\n    dependencies: [PublishPageUseCase]\n});\n"],"names":["PublishPageActionHandlerImpl","publishPageUseCase","namespace","actionType","extractModelIdFromNamespace","SCHEDULED_ACTION_TYPE_PAGE","ScheduledActionTypePublish","action","result","console","Error","PublishPageActionHandler","ScheduledActionHandler","PublishPageUseCase"],"mappings":";;;;AAcA,MAAMA;IACF,YAAoBC,kBAAgD,CAAE;aAAlDA,kBAAkB,GAAlBA;IAAmD;IAEhE,UAAUC,SAAiB,EAAEC,UAA+B,EAAW;QAC1E,OACIC,4BAA4BF,eAAeG,8BAC3CF,eAAeG;IAEvB;IAEA,MAAa,OAAOC,MAAiD,EAAiB;QAClF,MAAMC,SAAS,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YAAE,IAAID,OAAO,QAAQ;QAAC;QAC3E,IAAIC,OAAO,MAAM,IAAI;YACjBC,QAAQ,KAAK,CAAC,CAAC,wBAAwB,EAAEF,OAAO,QAAQ,CAAC,EAAE,CAAC,EAAEC,OAAO,KAAK;YAC1E,MAAM,IAAIE,MAAM,CAAC,wBAAwB,EAAEH,OAAO,QAAQ,EAAE;QAChE;IACJ;AACJ;AAEO,MAAMI,2BAA2BC,uBAAuB,oBAAoB,CAAC;IAChF,gBAAgBZ;IAChB,cAAc;QAACa;KAAmB;AACtC"}