@webiny/api-headless-cms-scheduler 0.0.0-unstable.0156a4c312

package/CmsSchedulerFeature.d.ts

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

package/CmsSchedulerFeature.js

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

package/CmsSchedulerFeature.js.map

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

package/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-headless-cms-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/exports/api/cms/scheduler.d.ts

@@ -0,0 +1,2 @@
+export { SchedulePublishEntryUseCase } from "../../../features/SchedulePublishEntryUseCase/abstractions.js";
+export { ScheduleUnpublishEntryUseCase } from "../../../features/ScheduleUnpublishEntryUseCase/abstractions.js";

package/exports/api/cms/scheduler.js

@@ -0,0 +1,2 @@
+export { SchedulePublishEntryUseCase } from "../../../features/SchedulePublishEntryUseCase/abstractions.js";
+export { ScheduleUnpublishEntryUseCase } from "../../../features/ScheduleUnpublishEntryUseCase/abstractions.js";

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.d.ts

@@ -0,0 +1,22 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+/**
+ * Cancels scheduled actions when an entry is deleted
+ *
+ * When a user deletes an entry, any scheduled publish/unpublish
+ * actions for all of its revisions should be canceled since the entry
+ * no longer exists.
+ */
+declare class CancelScheduledActionOnEntryDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
+    handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
+    private listSchedules;
+}
+export declare const CancelScheduledActionOnEntryDeleteEventHandler: typeof CancelScheduledActionOnEntryDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
+};
+export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js

@@ -0,0 +1,49 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { createNamespace } from "../../utils/namespace.js";
+class CancelScheduledActionOnEntryDeleteHandlerImpl {
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const schedules = await this.listSchedules(model.modelId, entry.entryId);
+        for (const action of schedules){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
+    }
+    async listSchedules(modelId, entryId) {
+        const actionsResult = await this.listScheduledActions.execute({
+            limit: 10000,
+            where: {
+                namespace: createNamespace({
+                    modelId
+                }),
+                targetId_startsWith: `${entryId}#`
+            }
+        });
+        if (actionsResult.isFail()) {
+            this.logger.error({
+                error: actionsResult.error
+            }, "Could not list scheduled actions to cancel.");
+            return [];
+        }
+        return actionsResult.value.items;
+    }
+}
+const CancelScheduledActionOnEntryDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
+});
+export { CancelScheduledActionOnEntryDeleteEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnEntryDeleteEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry is deleted\n *\n * When a user deletes an entry, any scheduled publish/unpublish\n * actions for all of its revisions should be canceled since the entry\n * no longer exists.\n */\nclass CancelScheduledActionOnEntryDeleteHandlerImpl\n    implements EntryAfterDeleteEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const schedules = await this.listSchedules(model.modelId, entry.entryId);\n        for (const action of schedules) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // The entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n\n    private async listSchedules(modelId: string, entryId: string) {\n        const actionsResult = await this.listScheduledActions.execute({\n            limit: 10000,\n            where: {\n                namespace: createNamespace({ modelId }),\n                targetId_startsWith: `${entryId}#`\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return [];\n        }\n\n        return actionsResult.value.items;\n    }\n}\n\nexport const CancelScheduledActionOnEntryDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnEntryDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","schedules","action","cancelRes","modelId","entryId","actionsResult","createNamespace","CancelScheduledActionOnEntryDeleteEventHandler","EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAeA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAACD,MAAM,OAAO,EAAED,MAAM,OAAO;QACvE,KAAK,MAAMG,UAAUD,UAAW;YAC5B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;IAEA,MAAc,cAAcC,OAAe,EAAEC,OAAe,EAAE;QAC1D,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;YACP,OAAO;gBACH,WAAWC,gBAAgB;oBAAEH;gBAAQ;gBACrC,qBAAqB,GAAGC,QAAQ,CAAC,CAAC;YACtC;QACJ;QAEA,IAAIC,cAAc,MAAM,IAAI;YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,OAAOA,cAAc,KAAK;YAAC,GAC7B;YAEJ,OAAO,EAAE;QACb;QAEA,OAAOA,cAAc,KAAK,CAAC,KAAK;IACpC;AACJ;AAEO,MAAME,iDACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBf;IAChB,cAAc;QAACgB;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.d.ts

@@ -0,0 +1,21 @@
+import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+/**
+ * Cancels scheduled "publish" when an entry is manually published
+ *
+ * When a user manually publishes an entry, any scheduled publish
+ * action for that entry should be canceled since the manual action
+ * takes precedence.
+ */
+declare class CancelScheduledActionOnPublishEventHandlerImpl implements EntryAfterPublishEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
+    handle(event: EntryAfterPublishEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnPublishEventHandler: typeof CancelScheduledActionOnPublishEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/PublishEntry/events").EntryAfterPublishEvent>>;
+};
+export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js

@@ -0,0 +1,41 @@
+import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { createNamespace } from "../../utils/namespace.js";
+class CancelScheduledActionOnPublishEventHandlerImpl {
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                actionType: ScheduledActionTypePublish,
+                targetId: entry.id
+            }
+        });
+        if (actionsResult.isFail()) return void this.logger.error({
+            error: actionsResult.error
+        }, "Could not list scheduled actions to cancel.");
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnPublishEventHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
+});
+export { CancelScheduledActionOnPublishEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnPublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.ts"],"sourcesContent":["import { EntryAfterPublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled \"publish\" when an entry is manually published\n *\n * When a user manually publishes an entry, any scheduled publish\n * action for that entry should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnPublishEventHandlerImpl\n    implements EntryAfterPublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterPublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: ScheduledActionTypePublish,\n                targetId: entry.id\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return;\n        }\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Even if a schedule runs on an already published action, nothing bad will happen.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPublishEventHandler =\n    EntryAfterPublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnPublishEventHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnPublishEventHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","actionsResult","createNamespace","ScheduledActionTypePublish","actions","action","cancelRes","CancelScheduledActionOnPublishEventHandler","EntryAfterPublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAgBA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAA0C,EAAiB;QACpE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBF;gBAC3B,YAAYG;gBACZ,UAAUJ,MAAM,EAAE;YACtB;QACJ;QAEA,IAAIE,cAAc,MAAM,IAAI,YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;YAAE,OAAOA,cAAc,KAAK;QAAC,GAC7B;QAKR,MAAMG,UAAUH,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMI,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,6CACTC,8BAA8B,oBAAoB,CAAC;IAC/C,gBAAgBd;IAChB,cAAc;QAACe;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.d.ts

@@ -0,0 +1,21 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+/**
+ * Cancels scheduled actions when an entry revision is deleted
+ *
+ * When a user deletes an entry revision, any scheduled publish/unpublish
+ * action for that revision should be canceled since the revision
+ * no longer exists.
+ */
+declare class CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
+    handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnRevisionDeleteEventHandler: typeof CancelScheduledActionOnDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
+};
+export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js

@@ -0,0 +1,40 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { createNamespace } from "../../utils/namespace.js";
+class CancelScheduledActionOnDeleteHandlerImpl {
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                targetId: entry.id
+            }
+        });
+        if (actionsResult.isFail()) return void this.logger.error({
+            error: actionsResult.error
+        }, "Could not list scheduled actions to cancel.");
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnRevisionDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
+});
+export { CancelScheduledActionOnRevisionDeleteEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnRevisionDeleteEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry revision is deleted\n *\n * When a user deletes an entry revision, any scheduled publish/unpublish\n * action for that revision should be canceled since the revision\n * no longer exists.\n */\nclass CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                targetId: entry.id\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return;\n        }\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnRevisionDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","actionsResult","createNamespace","actions","action","cancelRes","CancelScheduledActionOnRevisionDeleteEventHandler","EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAeA,MAAMA;IACF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBF;gBAC3B,UAAUD,MAAM,EAAE;YACtB;QACJ;QAEA,IAAIE,cAAc,MAAM,IAAI,YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;YAAE,OAAOA,cAAc,KAAK;QAAC,GAC7B;QAKR,MAAME,UAAUF,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMG,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,oDACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.d.ts

@@ -0,0 +1,21 @@
+import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+/**
+ * Cancels scheduled action when an entry is manually unpublished
+ *
+ * When a user manually unpublishes an entry revision, any scheduled unpublish
+ * action for that revision should be canceled since the manual action
+ * takes precedence.
+ */
+declare class CancelScheduledActionOnUnpublishHandlerImpl implements EntryAfterUnpublishEventHandler.Interface {
+    private listScheduledActions;
+    private cancelScheduledAction;
+    private logger;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.Interface, logger: Logger.Interface);
+    handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void>;
+}
+export declare const CancelScheduledActionOnUnpublishEventHandler: typeof CancelScheduledActionOnUnpublishHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events").EntryAfterUnpublishEvent>>;
+};
+export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js

@@ -0,0 +1,41 @@
+import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { createNamespace } from "../../utils/namespace.js";
+class CancelScheduledActionOnUnpublishHandlerImpl {
+    constructor(listScheduledActions, cancelScheduledAction, logger){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+        this.logger = logger;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                actionType: ScheduledActionTypeUnpublish,
+                targetId: entry.id
+            }
+        });
+        if (actionsResult.isFail()) return void this.logger.error({
+            error: actionsResult.error
+        }, "Could not list scheduled actions to cancel.");
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
+    }
+}
+const CancelScheduledActionOnUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnUnpublishHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase,
+        Logger
+    ]
+});
+export { CancelScheduledActionOnUnpublishEventHandler };
+
+//# sourceMappingURL=CancelScheduledActionOnUnpublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.ts"],"sourcesContent":["import { EntryAfterUnpublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled action when an entry is manually unpublished\n *\n * When a user manually unpublishes an entry revision, any scheduled unpublish\n * action for that revision should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnUnpublishHandlerImpl\n    implements EntryAfterUnpublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    async handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: ScheduledActionTypeUnpublish,\n                targetId: entry.id\n            }\n        });\n\n        if (actionsResult.isFail()) {\n            this.logger.error(\n                { error: actionsResult.error },\n                \"Could not list scheduled actions to cancel.\"\n            );\n            return;\n        }\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was unpublished successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnUnpublishEventHandler =\n    EntryAfterUnpublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnUnpublishHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase, Logger]\n    });\n"],"names":["CancelScheduledActionOnUnpublishHandlerImpl","listScheduledActions","cancelScheduledAction","logger","event","entry","model","actionsResult","createNamespace","ScheduledActionTypeUnpublish","actions","action","cancelRes","CancelScheduledActionOnUnpublishEventHandler","EntryAfterUnpublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","Logger"],"mappings":";;;;AAgBA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,EAC7DC,MAAwB,CAClC;aAHUF,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAGtC,IAAIE,MAAM,SAAS,EACf;QAGJ,MAAMC,gBAAgB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YAC1D,OAAO;gBACH,WAAWC,gBAAgBF;gBAC3B,YAAYG;gBACZ,UAAUJ,MAAM,EAAE;YACtB;QACJ;QAEA,IAAIE,cAAc,MAAM,IAAI,YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;YAAE,OAAOA,cAAc,KAAK;QAAC,GAC7B;QAKR,MAAMG,UAAUH,cAAc,KAAK,CAAC,KAAK;QAEzC,KAAK,MAAMI,UAAUD,QAAS;YAC1B,MAAME,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACD;YACvDC,UAAU,MAAM;QAIxB;IACJ;AACJ;AAEO,MAAMC,+CACTC,gCAAgC,oBAAoB,CAAC;IACjD,gBAAgBd;IAChB,cAAc;QAACe;QAA6BC;QAA8BC;KAAO;AACrF"}

package/features/CancelScheduledActionOnEntryChange/feature.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CancelScheduledActionOnEntryChange Feature
+ *
+ * Automatically cancels scheduled actions when entries 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 CancelScheduledActionOnEntryChangeFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/CancelScheduledActionOnEntryChange/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { CancelScheduledActionOnPublishEventHandler } from "./CancelScheduledActionOnPublishEventHandler.js";
+import { CancelScheduledActionOnUnpublishEventHandler } from "./CancelScheduledActionOnUnpublishEventHandler.js";
+import { CancelScheduledActionOnEntryDeleteEventHandler } from "./CancelScheduledActionOnEntryDeleteEventHandler.js";
+import { CancelScheduledActionOnRevisionDeleteEventHandler } from "./CancelScheduledActionOnRevisionDeleteEventHandler.js";
+const CancelScheduledActionOnEntryChangeFeature = createFeature({
+    name: "CancelScheduledActionOnEntryChange",
+    register (container) {
+        container.register(CancelScheduledActionOnPublishEventHandler);
+        container.register(CancelScheduledActionOnUnpublishEventHandler);
+        container.register(CancelScheduledActionOnEntryDeleteEventHandler);
+        container.register(CancelScheduledActionOnRevisionDeleteEventHandler);
+    }
+});
+export { CancelScheduledActionOnEntryChangeFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/CancelScheduledActionOnEntryChange/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/feature.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CancelScheduledActionOnPublishEventHandler } from \"./CancelScheduledActionOnPublishEventHandler.js\";\nimport { CancelScheduledActionOnUnpublishEventHandler } from \"./CancelScheduledActionOnUnpublishEventHandler.js\";\nimport { CancelScheduledActionOnEntryDeleteEventHandler } from \"./CancelScheduledActionOnEntryDeleteEventHandler.js\";\nimport { CancelScheduledActionOnRevisionDeleteEventHandler } from \"./CancelScheduledActionOnRevisionDeleteEventHandler.js\";\n\n/**\n * CancelScheduledActionOnEntryChange Feature\n *\n * Automatically cancels scheduled actions when entries 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 CancelScheduledActionOnEntryChangeFeature = createFeature({\n    name: \"CancelScheduledActionOnEntryChange\",\n    register(container) {\n        container.register(CancelScheduledActionOnPublishEventHandler);\n        container.register(CancelScheduledActionOnUnpublishEventHandler);\n        container.register(CancelScheduledActionOnEntryDeleteEventHandler);\n        container.register(CancelScheduledActionOnRevisionDeleteEventHandler);\n    }\n});\n"],"names":["CancelScheduledActionOnEntryChangeFeature","createFeature","container","CancelScheduledActionOnPublishEventHandler","CancelScheduledActionOnUnpublishEventHandler","CancelScheduledActionOnEntryDeleteEventHandler","CancelScheduledActionOnRevisionDeleteEventHandler"],"mappings":";;;;;AAaO,MAAMA,4CAA4CC,cAAc;IACnE,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/NamespaceHandler.d.ts

@@ -0,0 +1,15 @@
+import { NamespaceHandler as NamespaceHandlerAbstraction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+declare class NamespaceHandlerImpl implements NamespaceHandlerAbstraction.Interface<GenericRecord> {
+    private getModelUseCase;
+    private getEntryByIdUseCase;
+    constructor(getModelUseCase: GetModelUseCase.Interface, getEntryByIdUseCase: GetEntryByIdUseCase.Interface);
+    canHandle(namespace: string): boolean;
+    execute(params: NamespaceHandlerAbstraction.Params): NamespaceHandlerAbstraction.Response<GenericRecord>;
+}
+export declare const NamespaceHandler: typeof NamespaceHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/features/NamespaceHandler/abstractions").INamespaceHandler<GenericRecord>>;
+};
+export {};

package/features/NamespaceHandler/NamespaceHandler.js

@@ -0,0 +1,44 @@
+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 { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+class NamespaceHandlerImpl {
+    constructor(getModelUseCase, getEntryByIdUseCase){
+        this.getModelUseCase = getModelUseCase;
+        this.getEntryByIdUseCase = getEntryByIdUseCase;
+    }
+    canHandle(namespace) {
+        const modelId = extractModelIdFromNamespace(namespace);
+        return !!modelId;
+    }
+    async execute(params) {
+        const modelId = extractModelIdFromNamespace(params.namespace);
+        const modelResult = await this.getModelUseCase.execute(modelId);
+        if (modelResult.isFail()) return Result.fail(modelResult.error);
+        const model = modelResult.value;
+        const entryResult = await this.getEntryByIdUseCase.execute(model, params.targetId);
+        if (entryResult.isFail()) return Result.fail(entryResult.error);
+        const entry = entryResult.value;
+        const title = entry.values[model.titleFieldId] || "Unknown entry title";
+        return Result.ok({
+            namespace: params.namespace,
+            title,
+            modelId,
+            actionType: params.actionType,
+            targetId: params.targetId,
+            scheduleId: params.scheduleId,
+            immediately: params.immediately || false
+        });
+    }
+}
+const NamespaceHandler_NamespaceHandler = NamespaceHandler.createImplementation({
+    implementation: NamespaceHandlerImpl,
+    dependencies: [
+        GetModelUseCase,
+        GetEntryByIdUseCase
+    ]
+});
+export { NamespaceHandler_NamespaceHandler as NamespaceHandler };
+
+//# sourceMappingURL=NamespaceHandler.js.map

package/features/NamespaceHandler/NamespaceHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/NamespaceHandler/NamespaceHandler.js","sources":["../../../src/features/NamespaceHandler/NamespaceHandler.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 { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nclass NamespaceHandlerImpl implements NamespaceHandlerAbstraction.Interface<GenericRecord> {\n    public constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface\n    ) {}\n\n    public canHandle(namespace: string): boolean {\n        const modelId = extractModelIdFromNamespace(namespace);\n\n        return !!modelId;\n    }\n\n    public async execute(\n        params: NamespaceHandlerAbstraction.Params\n    ): NamespaceHandlerAbstraction.Response<GenericRecord> {\n        /**\n         * We know that modelId is ok because of the canHandle() method, which is always called before execute() and must return true for this handler to be executed.\n         */\n        const modelId = extractModelIdFromNamespace(params.namespace)!;\n        // Fetch the target model\n        const modelResult = await this.getModelUseCase.execute(modelId);\n        if (modelResult.isFail()) {\n            return Result.fail(modelResult.error as any);\n        }\n\n        const model = modelResult.value;\n\n        // Fetch entry to get title\n        const entryResult = await this.getEntryByIdUseCase.execute(model, params.targetId);\n        if (entryResult.isFail()) {\n            return Result.fail(entryResult.error as any);\n        }\n\n        const entry = entryResult.value;\n        const title = entry.values[model.titleFieldId] || \"Unknown entry title\";\n\n        return Result.ok({\n            namespace: params.namespace,\n            title,\n            modelId,\n            actionType: params.actionType,\n            targetId: params.targetId,\n            scheduleId: params.scheduleId,\n            immediately: params.immediately || false\n        });\n    }\n}\n\nexport const NamespaceHandler = NamespaceHandlerAbstraction.createImplementation({\n    implementation: NamespaceHandlerImpl,\n    dependencies: [GetModelUseCase, GetEntryByIdUseCase]\n});\n"],"names":["NamespaceHandlerImpl","getModelUseCase","getEntryByIdUseCase","namespace","modelId","extractModelIdFromNamespace","params","modelResult","Result","model","entryResult","entry","title","NamespaceHandler","NamespaceHandlerAbstraction","GetModelUseCase","GetEntryByIdUseCase"],"mappings":";;;;;AAOA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,mBAAkD,CAC5D;aAFUD,eAAe,GAAfA;aACAC,mBAAmB,GAAnBA;IACT;IAEI,UAAUC,SAAiB,EAAW;QACzC,MAAMC,UAAUC,4BAA4BF;QAE5C,OAAO,CAAC,CAACC;IACb;IAEA,MAAa,QACTE,MAA0C,EACS;QAInD,MAAMF,UAAUC,4BAA4BC,OAAO,SAAS;QAE5D,MAAMC,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACH;QACvD,IAAIG,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAGxC,MAAME,QAAQF,YAAY,KAAK;QAG/B,MAAMG,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAACD,OAAOH,OAAO,QAAQ;QACjF,IAAII,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAACE,YAAY,KAAK;QAGxC,MAAMC,QAAQD,YAAY,KAAK;QAC/B,MAAME,QAAQD,MAAM,MAAM,CAACF,MAAM,YAAY,CAAC,IAAI;QAElD,OAAOD,OAAO,EAAE,CAAC;YACb,WAAWF,OAAO,SAAS;YAC3BM;YACAR;YACA,YAAYE,OAAO,UAAU;YAC7B,UAAUA,OAAO,QAAQ;YACzB,YAAYA,OAAO,UAAU;YAC7B,aAAaA,OAAO,WAAW,IAAI;QACvC;IACJ;AACJ;AAEO,MAAMO,oCAAmBC,iBAAAA,oBAAgD,CAAC;IAC7E,gBAAgBd;IAChB,cAAc;QAACe;QAAiBC;KAAoB;AACxD"}

package/features/PublishActionHandler/PublishEntryActionHandler.d.ts

@@ -0,0 +1,35 @@
+import { ScheduledActionHandler, ScheduledActionType, type IScheduledAction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetPublishedEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds";
+import { PublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry";
+import { UnpublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry";
+import { RepublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/RepublishEntry";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { IScheduledActionPayload } from "../../types.js";
+/**
+ * Handler for publishing CMS entries
+ *
+ * Handles the "Publish" action for CMS entries with namespace pattern: Cms/Entry/{modelId}
+ *
+ * Publishing logic:
+ * 1. If entry is not published -> publish it
+ * 2. If the same revision is already published -> republish it
+ * 3. If a different revision is published -> unpublish old, publish new
+ */
+declare class PublishEntryActionHandlerImpl implements ScheduledActionHandler.Interface {
+    private getModelUseCase;
+    private getEntryByIdUseCase;
+    private getPublishedEntriesByIdsUseCase;
+    private publishEntryUseCase;
+    private unpublishEntryUseCase;
+    private republishEntryUseCase;
+    private identityContext;
+    constructor(getModelUseCase: GetModelUseCase.Interface, getEntryByIdUseCase: GetEntryByIdUseCase.Interface, getPublishedEntriesByIdsUseCase: GetPublishedEntriesByIdsUseCase.Interface, publishEntryUseCase: PublishEntryUseCase.Interface, unpublishEntryUseCase: UnpublishEntryUseCase.Interface, republishEntryUseCase: RepublishEntryUseCase.Interface, identityContext: IdentityContext.Interface);
+    canHandle(namespace: string, actionType: ScheduledActionType): boolean;
+    handle(action: IScheduledAction<IScheduledActionPayload>): Promise<void>;
+}
+export declare const PublishEntryActionHandler: typeof PublishEntryActionHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/shared/abstractions").IScheduledActionHandler>;
+};
+export {};

package/features/PublishActionHandler/PublishEntryActionHandler.js

@@ -0,0 +1,92 @@
+import { ScheduledActionHandler, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetPublishedEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds";
+import { PublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry";
+import { UnpublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry";
+import { RepublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/RepublishEntry";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { extractModelIdFromNamespace } from "../../utils/namespace.js";
+class PublishEntryActionHandlerImpl {
+    constructor(getModelUseCase, getEntryByIdUseCase, getPublishedEntriesByIdsUseCase, publishEntryUseCase, unpublishEntryUseCase, republishEntryUseCase, identityContext){
+        this.getModelUseCase = getModelUseCase;
+        this.getEntryByIdUseCase = getEntryByIdUseCase;
+        this.getPublishedEntriesByIdsUseCase = getPublishedEntriesByIdsUseCase;
+        this.publishEntryUseCase = publishEntryUseCase;
+        this.unpublishEntryUseCase = unpublishEntryUseCase;
+        this.republishEntryUseCase = republishEntryUseCase;
+        this.identityContext = identityContext;
+    }
+    canHandle(namespace, actionType) {
+        const modelId = extractModelIdFromNamespace(namespace);
+        if (!modelId) return false;
+        return actionType === ScheduledActionTypePublish;
+    }
+    async handle(action) {
+        const { payload } = action;
+        const modelId = payload.modelId;
+        const modelResult = await this.getModelUseCase.execute(modelId);
+        if (modelResult.isFail()) {
+            console.error(`Failed to get model "${modelId}" for scheduled publish action:`, modelResult.error, {
+                identity: this.identityContext.getIdentity()
+            });
+            throw new Error(`Model not found: ${modelId}`);
+        }
+        const model = modelResult.value;
+        const targetEntryResult = await this.getEntryByIdUseCase.execute(model, action.targetId);
+        if (targetEntryResult.isFail()) {
+            console.error(`Failed to get entry "${action.targetId}" for scheduled publish action:`, targetEntryResult.error);
+            throw new Error(`Entry not found: ${action.targetId}`);
+        }
+        const targetEntry = targetEntryResult.value;
+        const publishedEntriesResult = await this.getPublishedEntriesByIdsUseCase.execute(model, [
+            targetEntry.id
+        ]);
+        if (publishedEntriesResult.isFail()) {
+            console.error(`Failed to get published entries for "${targetEntry.id}":`, publishedEntriesResult.error);
+            throw new Error("Failed to check published entries");
+        }
+        const [publishedTargetEntry] = publishedEntriesResult.value;
+        if (!publishedTargetEntry) {
+            const publishResult = await this.publishEntryUseCase.execute(model, targetEntry.id);
+            if (publishResult.isFail()) {
+                console.error(`Failed to publish entry "${action.targetId}":`, publishResult.error);
+                throw new Error(`Failed to publish entry: ${action.targetId}`);
+            }
+            return;
+        }
+        if (publishedTargetEntry.id === targetEntry.id) {
+            const republishResult = await this.republishEntryUseCase.execute(model, targetEntry.id);
+            if (republishResult.isFail()) {
+                console.error(`Failed to republish entry "${action.targetId}":`, republishResult.error);
+                throw new Error(`Failed to republish entry: ${action.targetId}`);
+            }
+            return;
+        }
+        const unpublishResult = await this.unpublishEntryUseCase.execute(model, publishedTargetEntry.id);
+        if (unpublishResult.isFail()) {
+            console.error(`Failed to unpublish old revision "${publishedTargetEntry.id}":`, unpublishResult.error);
+            throw new Error(`Failed to unpublish old revision: ${publishedTargetEntry.id}`);
+        }
+        const publishResult = await this.publishEntryUseCase.execute(model, targetEntry.id);
+        if (publishResult.isFail()) {
+            console.error(`Failed to publish entry "${action.targetId}":`, publishResult.error);
+            throw new Error(`Failed to publish entry: ${action.targetId}`);
+        }
+    }
+}
+const PublishEntryActionHandler = ScheduledActionHandler.createImplementation({
+    implementation: PublishEntryActionHandlerImpl,
+    dependencies: [
+        GetModelUseCase,
+        GetEntryByIdUseCase,
+        GetPublishedEntriesByIdsUseCase,
+        PublishEntryUseCase,
+        UnpublishEntryUseCase,
+        RepublishEntryUseCase,
+        IdentityContext
+    ]
+});
+export { PublishEntryActionHandler };
+
+//# sourceMappingURL=PublishEntryActionHandler.js.map

package/features/PublishActionHandler/PublishEntryActionHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/PublishActionHandler/PublishEntryActionHandler.js","sources":["../../../src/features/PublishActionHandler/PublishEntryActionHandler.ts"],"sourcesContent":["import {\n    ScheduledActionHandler,\n    ScheduledActionType,\n    type IScheduledAction,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { GetPublishedEntriesByIdsUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds\";\nimport { PublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry\";\nimport { UnpublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry\";\nimport { RepublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/RepublishEntry\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { IScheduledActionPayload } from \"~/types.js\";\nimport { extractModelIdFromNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Handler for publishing CMS entries\n *\n * Handles the \"Publish\" action for CMS entries with namespace pattern: Cms/Entry/{modelId}\n *\n * Publishing logic:\n * 1. If entry is not published -> publish it\n * 2. If the same revision is already published -> republish it\n * 3. If a different revision is published -> unpublish old, publish new\n */\nclass PublishEntryActionHandlerImpl implements ScheduledActionHandler.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface,\n        private getPublishedEntriesByIdsUseCase: GetPublishedEntriesByIdsUseCase.Interface,\n        private publishEntryUseCase: PublishEntryUseCase.Interface,\n        private unpublishEntryUseCase: UnpublishEntryUseCase.Interface,\n        private republishEntryUseCase: RepublishEntryUseCase.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    public canHandle(namespace: string, actionType: ScheduledActionType): boolean {\n        const modelId = extractModelIdFromNamespace(namespace);\n        if (!modelId) {\n            return false;\n        }\n        return actionType === ScheduledActionTypePublish;\n    }\n\n    public async handle(action: IScheduledAction<IScheduledActionPayload>): Promise<void> {\n        const { payload } = action;\n\n        const modelId = payload.modelId;\n\n        // Fetch the model\n        const modelResult = await this.getModelUseCase.execute(modelId);\n        if (modelResult.isFail()) {\n            console.error(\n                `Failed to get model \"${modelId}\" for scheduled publish action:`,\n                modelResult.error,\n                {\n                    identity: this.identityContext.getIdentity()\n                }\n            );\n            throw new Error(`Model not found: ${modelId}`);\n        }\n\n        const model = modelResult.value;\n\n        // Fetch the target entry\n        const targetEntryResult = await this.getEntryByIdUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, action.targetId);\n        if (targetEntryResult.isFail()) {\n            console.error(\n                `Failed to get entry \"${action.targetId}\" for scheduled publish action:`,\n                targetEntryResult.error\n            );\n            throw new Error(`Entry not found: ${action.targetId}`);\n        }\n\n        const targetEntry = targetEntryResult.value;\n\n        // Get published entries\n        const publishedEntriesResult = await this.getPublishedEntriesByIdsUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, [targetEntry.id]);\n\n        if (publishedEntriesResult.isFail()) {\n            console.error(\n                `Failed to get published entries for \"${targetEntry.id}\":`,\n                publishedEntriesResult.error\n            );\n            throw new Error(`Failed to check published entries`);\n        }\n\n        const [publishedTargetEntry] = publishedEntriesResult.value;\n\n        /**\n         * Scenario 1: Entry has no published revision -> publish it\n         */\n        if (!publishedTargetEntry) {\n            const publishResult = await this.publishEntryUseCase.execute<\n                IScheduledAction<IScheduledActionPayload>\n            >(model, targetEntry.id);\n            if (publishResult.isFail()) {\n                console.error(`Failed to publish entry \"${action.targetId}\":`, publishResult.error);\n                throw new Error(`Failed to publish entry: ${action.targetId}`);\n            }\n            return;\n        }\n\n        /**\n         * Scenario 2: Target entry is already published (same revision) -> republish it\n         */\n        if (publishedTargetEntry.id === targetEntry.id) {\n            const republishResult = await this.republishEntryUseCase.execute(model, targetEntry.id);\n            if (republishResult.isFail()) {\n                console.error(\n                    `Failed to republish entry \"${action.targetId}\":`,\n                    republishResult.error\n                );\n                throw new Error(`Failed to republish entry: ${action.targetId}`);\n            }\n            return;\n        }\n\n        /**\n         * Scenario 3: A different revision is published -> unpublish old, publish new\n         */\n        const unpublishResult = await this.unpublishEntryUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, publishedTargetEntry.id);\n        if (unpublishResult.isFail()) {\n            console.error(\n                `Failed to unpublish old revision \"${publishedTargetEntry.id}\":`,\n                unpublishResult.error\n            );\n            throw new Error(`Failed to unpublish old revision: ${publishedTargetEntry.id}`);\n        }\n\n        const publishResult = await this.publishEntryUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, targetEntry.id);\n        if (publishResult.isFail()) {\n            console.error(`Failed to publish entry \"${action.targetId}\":`, publishResult.error);\n            throw new Error(`Failed to publish entry: ${action.targetId}`);\n        }\n    }\n}\n\nexport const PublishEntryActionHandler = ScheduledActionHandler.createImplementation({\n    implementation: PublishEntryActionHandlerImpl,\n    dependencies: [\n        GetModelUseCase,\n        GetEntryByIdUseCase,\n        GetPublishedEntriesByIdsUseCase,\n        PublishEntryUseCase,\n        UnpublishEntryUseCase,\n        RepublishEntryUseCase,\n        IdentityContext\n    ]\n});\n"],"names":["PublishEntryActionHandlerImpl","getModelUseCase","getEntryByIdUseCase","getPublishedEntriesByIdsUseCase","publishEntryUseCase","unpublishEntryUseCase","republishEntryUseCase","identityContext","namespace","actionType","modelId","extractModelIdFromNamespace","ScheduledActionTypePublish","action","payload","modelResult","console","Error","model","targetEntryResult","targetEntry","publishedEntriesResult","publishedTargetEntry","publishResult","republishResult","unpublishResult","PublishEntryActionHandler","ScheduledActionHandler","GetModelUseCase","GetEntryByIdUseCase","GetPublishedEntriesByIdsUseCase","PublishEntryUseCase","UnpublishEntryUseCase","RepublishEntryUseCase","IdentityContext"],"mappings":";;;;;;;;;AA0BA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,mBAAkD,EAClDC,+BAA0E,EAC1EC,mBAAkD,EAClDC,qBAAsD,EACtDC,qBAAsD,EACtDC,eAA0C,CACpD;aAPUN,eAAe,GAAfA;aACAC,mBAAmB,GAAnBA;aACAC,+BAA+B,GAA/BA;aACAC,mBAAmB,GAAnBA;aACAC,qBAAqB,GAArBA;aACAC,qBAAqB,GAArBA;aACAC,eAAe,GAAfA;IACT;IAEI,UAAUC,SAAiB,EAAEC,UAA+B,EAAW;QAC1E,MAAMC,UAAUC,4BAA4BH;QAC5C,IAAI,CAACE,SACD,OAAO;QAEX,OAAOD,eAAeG;IAC1B;IAEA,MAAa,OAAOC,MAAiD,EAAiB;QAClF,MAAM,EAAEC,OAAO,EAAE,GAAGD;QAEpB,MAAMH,UAAUI,QAAQ,OAAO;QAG/B,MAAMC,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACL;QACvD,IAAIK,YAAY,MAAM,IAAI;YACtBC,QAAQ,KAAK,CACT,CAAC,qBAAqB,EAAEN,QAAQ,+BAA+B,CAAC,EAChEK,YAAY,KAAK,EACjB;gBACI,UAAU,IAAI,CAAC,eAAe,CAAC,WAAW;YAC9C;YAEJ,MAAM,IAAIE,MAAM,CAAC,iBAAiB,EAAEP,SAAS;QACjD;QAEA,MAAMQ,QAAQH,YAAY,KAAK;QAG/B,MAAMI,oBAAoB,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAE9DD,OAAOL,OAAO,QAAQ;QACxB,IAAIM,kBAAkB,MAAM,IAAI;YAC5BH,QAAQ,KAAK,CACT,CAAC,qBAAqB,EAAEH,OAAO,QAAQ,CAAC,+BAA+B,CAAC,EACxEM,kBAAkB,KAAK;YAE3B,MAAM,IAAIF,MAAM,CAAC,iBAAiB,EAAEJ,OAAO,QAAQ,EAAE;QACzD;QAEA,MAAMO,cAAcD,kBAAkB,KAAK;QAG3C,MAAME,yBAAyB,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,CAE/EH,OAAO;YAACE,YAAY,EAAE;SAAC;QAEzB,IAAIC,uBAAuB,MAAM,IAAI;YACjCL,QAAQ,KAAK,CACT,CAAC,qCAAqC,EAAEI,YAAY,EAAE,CAAC,EAAE,CAAC,EAC1DC,uBAAuB,KAAK;YAEhC,MAAM,IAAIJ,MAAM;QACpB;QAEA,MAAM,CAACK,qBAAqB,GAAGD,uBAAuB,KAAK;QAK3D,IAAI,CAACC,sBAAsB;YACvB,MAAMC,gBAAgB,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAE1DL,OAAOE,YAAY,EAAE;YACvB,IAAIG,cAAc,MAAM,IAAI;gBACxBP,QAAQ,KAAK,CAAC,CAAC,yBAAyB,EAAEH,OAAO,QAAQ,CAAC,EAAE,CAAC,EAAEU,cAAc,KAAK;gBAClF,MAAM,IAAIN,MAAM,CAAC,yBAAyB,EAAEJ,OAAO,QAAQ,EAAE;YACjE;YACA;QACJ;QAKA,IAAIS,qBAAqB,EAAE,KAAKF,YAAY,EAAE,EAAE;YAC5C,MAAMI,kBAAkB,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACN,OAAOE,YAAY,EAAE;YACtF,IAAII,gBAAgB,MAAM,IAAI;gBAC1BR,QAAQ,KAAK,CACT,CAAC,2BAA2B,EAAEH,OAAO,QAAQ,CAAC,EAAE,CAAC,EACjDW,gBAAgB,KAAK;gBAEzB,MAAM,IAAIP,MAAM,CAAC,2BAA2B,EAAEJ,OAAO,QAAQ,EAAE;YACnE;YACA;QACJ;QAKA,MAAMY,kBAAkB,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAE9DP,OAAOI,qBAAqB,EAAE;QAChC,IAAIG,gBAAgB,MAAM,IAAI;YAC1BT,QAAQ,KAAK,CACT,CAAC,kCAAkC,EAAEM,qBAAqB,EAAE,CAAC,EAAE,CAAC,EAChEG,gBAAgB,KAAK;YAEzB,MAAM,IAAIR,MAAM,CAAC,kCAAkC,EAAEK,qBAAqB,EAAE,EAAE;QAClF;QAEA,MAAMC,gBAAgB,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAE1DL,OAAOE,YAAY,EAAE;QACvB,IAAIG,cAAc,MAAM,IAAI;YACxBP,QAAQ,KAAK,CAAC,CAAC,yBAAyB,EAAEH,OAAO,QAAQ,CAAC,EAAE,CAAC,EAAEU,cAAc,KAAK;YAClF,MAAM,IAAIN,MAAM,CAAC,yBAAyB,EAAEJ,OAAO,QAAQ,EAAE;QACjE;IACJ;AACJ;AAEO,MAAMa,4BAA4BC,uBAAuB,oBAAoB,CAAC;IACjF,gBAAgB3B;IAChB,cAAc;QACV4B;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.d.ts

@@ -0,0 +1,15 @@
+import { SchedulePublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduleActionUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { AccessControl } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+declare class SchedulePublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private scheduleAction;
+    private accessControl;
+    private getModelUseCase;
+    constructor(scheduleAction: ScheduleActionUseCase.Interface, accessControl: AccessControl.Interface, getModelUseCase: GetModelUseCase.Interface);
+    execute(params: UseCaseAbstraction.Params): UseCaseAbstraction.Result;
+}
+export declare const SchedulePublishEntryUseCase: typeof SchedulePublishEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ISchedulePublishEntryUseCase>;
+};
+export {};

package/features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.js

@@ -0,0 +1,47 @@
+import { SchedulePublishEntryUseCase } from "./abstractions.js";
+import { ScheduleActionUseCase, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+import { Result } from "@webiny/feature/exports/api.js";
+import { EntryNotAuthorizedError } from "@webiny/api-headless-cms/domain/contentEntry/errors.js";
+import { AccessControl } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+class SchedulePublishEntryUseCaseImpl {
+    constructor(scheduleAction, accessControl, getModelUseCase){
+        this.scheduleAction = scheduleAction;
+        this.accessControl = accessControl;
+        this.getModelUseCase = getModelUseCase;
+    }
+    async execute(params) {
+        const { model: initialModel, tenant, scheduleFor, id } = params;
+        const modelResult = await this.getModelUseCase.execute(initialModel.modelId);
+        if (modelResult.isFail()) return Result.fail(modelResult.error);
+        const model = modelResult.value;
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            pw: "p"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const scheduleResult = await this.scheduleAction.execute({
+            namespace: createNamespace(model),
+            actionType: ScheduledActionTypePublish,
+            scheduleFor,
+            tenant,
+            targetId: id
+        });
+        if (scheduleResult.isFail()) return Result.fail(scheduleResult.error);
+        return Result.ok({
+            scheduledAction: scheduleResult.value
+        });
+    }
+}
+const SchedulePublishEntryUseCase_SchedulePublishEntryUseCase = SchedulePublishEntryUseCase.createImplementation({
+    implementation: SchedulePublishEntryUseCaseImpl,
+    dependencies: [
+        ScheduleActionUseCase,
+        AccessControl,
+        GetModelUseCase
+    ]
+});
+export { SchedulePublishEntryUseCase_SchedulePublishEntryUseCase as SchedulePublishEntryUseCase };
+
+//# sourceMappingURL=SchedulePublishEntryUseCase.js.map

package/features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.js","sources":["../../../src/features/SchedulePublishEntryUseCase/SchedulePublishEntryUseCase.ts"],"sourcesContent":["import { SchedulePublishEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport {\n    ScheduleActionUseCase,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\nimport { Result } from \"@webiny/feature/exports/api.js\";\nimport { EntryNotAuthorizedError } from \"@webiny/api-headless-cms/domain/contentEntry/errors.js\";\nimport { AccessControl } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\n\nclass SchedulePublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private scheduleAction: ScheduleActionUseCase.Interface,\n        private accessControl: AccessControl.Interface,\n        private getModelUseCase: GetModelUseCase.Interface\n    ) {}\n\n    public async execute(params: UseCaseAbstraction.Params): UseCaseAbstraction.Result {\n        const { model: initialModel, tenant, scheduleFor, id } = params;\n\n        const modelResult = await this.getModelUseCase.execute(initialModel.modelId);\n        if (modelResult.isFail()) {\n            return Result.fail(modelResult.error as any);\n        }\n        const model = modelResult.value;\n\n        const canAccess = await this.accessControl.canAccessEntry({ model, pw: \"p\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model) as any);\n        }\n\n        const scheduleResult = await this.scheduleAction.execute({\n            namespace: createNamespace(model),\n            actionType: ScheduledActionTypePublish,\n            scheduleFor,\n            tenant,\n            targetId: id\n        });\n        if (scheduleResult.isFail()) {\n            return Result.fail(scheduleResult.error);\n        }\n        return Result.ok({\n            scheduledAction: scheduleResult.value\n        });\n    }\n}\n\nexport const SchedulePublishEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: SchedulePublishEntryUseCaseImpl,\n    dependencies: [ScheduleActionUseCase, AccessControl, GetModelUseCase]\n});\n"],"names":["SchedulePublishEntryUseCaseImpl","scheduleAction","accessControl","getModelUseCase","params","initialModel","tenant","scheduleFor","id","modelResult","Result","model","canAccess","EntryNotAuthorizedError","scheduleResult","createNamespace","ScheduledActionTypePublish","SchedulePublishEntryUseCase","UseCaseAbstraction","ScheduleActionUseCase","AccessControl","GetModelUseCase"],"mappings":";;;;;;;AAWA,MAAMA;IACF,YACYC,cAA+C,EAC/CC,aAAsC,EACtCC,eAA0C,CACpD;aAHUF,cAAc,GAAdA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAa,QAAQC,MAAiC,EAA6B;QAC/E,MAAM,EAAE,OAAOC,YAAY,EAAEC,MAAM,EAAEC,WAAW,EAAEC,EAAE,EAAE,GAAGJ;QAEzD,MAAMK,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACJ,aAAa,OAAO;QAC3E,IAAII,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAExC,MAAME,QAAQF,YAAY,KAAK;QAE/B,MAAMG,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAED;YAAO,IAAI;QAAI;QAC3E,IAAI,CAACC,WACD,OAAOF,OAAO,IAAI,CAACG,wBAAwB,SAAS,CAACF;QAGzD,MAAMG,iBAAiB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;YACrD,WAAWC,gBAAgBJ;YAC3B,YAAYK;YACZT;YACAD;YACA,UAAUE;QACd;QACA,IAAIM,eAAe,MAAM,IACrB,OAAOJ,OAAO,IAAI,CAACI,eAAe,KAAK;QAE3C,OAAOJ,OAAO,EAAE,CAAC;YACb,iBAAiBI,eAAe,KAAK;QACzC;IACJ;AACJ;AAEO,MAAMG,0DAA8BC,4BAAAA,oBAAuC,CAAC;IAC/E,gBAAgBlB;IAChB,cAAc;QAACmB;QAAuBC;QAAeC;KAAgB;AACzE"}

package/features/SchedulePublishEntryUseCase/abstractions.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import type { IScheduledAction, ScheduleActionError } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface ISchedulePublishEntryUseCaseParams {
+    id: string;
+    model: Pick<CmsModel, "modelId">;
+    tenant: string;
+    scheduleFor: Date;
+}
+export interface ISchedulePublishEntryUseCaseResult {
+    scheduledAction: IScheduledAction;
+}
+export type ISchedulePublishEntryUseCaseResponse = Promise<Result<ISchedulePublishEntryUseCaseResult, ScheduleActionError>>;
+export interface ISchedulePublishEntryUseCase {
+    execute(params: ISchedulePublishEntryUseCaseParams): ISchedulePublishEntryUseCaseResponse;
+}
+/** Schedule an entry for future publishing. */
+export declare const SchedulePublishEntryUseCase: import("@webiny/di").Abstraction<ISchedulePublishEntryUseCase>;
+export declare namespace SchedulePublishEntryUseCase {
+    type Interface = ISchedulePublishEntryUseCase;
+    type Error = ScheduleActionError;
+    type Params = ISchedulePublishEntryUseCaseParams;
+    type Result = ISchedulePublishEntryUseCaseResponse;
+}

package/features/SchedulePublishEntryUseCase/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const SchedulePublishEntryUseCase = createAbstraction("CmsScheduler/SchedulePublishEntryUseCase");
+export { SchedulePublishEntryUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/SchedulePublishEntryUseCase/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SchedulePublishEntryUseCase/abstractions.js","sources":["../../../src/features/SchedulePublishEntryUseCase/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type {\n    IScheduledAction,\n    ScheduleActionError\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface ISchedulePublishEntryUseCaseParams {\n    id: string;\n    model: Pick<CmsModel, \"modelId\">;\n    tenant: string;\n    scheduleFor: Date;\n}\n\nexport interface ISchedulePublishEntryUseCaseResult {\n    scheduledAction: IScheduledAction;\n}\n\nexport type ISchedulePublishEntryUseCaseResponse = Promise<\n    Result<ISchedulePublishEntryUseCaseResult, ScheduleActionError>\n>;\n\nexport interface ISchedulePublishEntryUseCase {\n    execute(params: ISchedulePublishEntryUseCaseParams): ISchedulePublishEntryUseCaseResponse;\n}\n\n/** Schedule an entry for future publishing. */\nexport const SchedulePublishEntryUseCase = createAbstraction<ISchedulePublishEntryUseCase>(\n    \"CmsScheduler/SchedulePublishEntryUseCase\"\n);\n\nexport namespace SchedulePublishEntryUseCase {\n    export type Interface = ISchedulePublishEntryUseCase;\n    export type Error = ScheduleActionError;\n    export type Params = ISchedulePublishEntryUseCaseParams;\n    export type Result = ISchedulePublishEntryUseCaseResponse;\n}\n"],"names":["SchedulePublishEntryUseCase","createAbstraction"],"mappings":";AA2BO,MAAMA,8BAA8BC,kBACvC"}

package/features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.d.ts

@@ -0,0 +1,15 @@
+import { ScheduleUnpublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduleActionUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { AccessControl } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+declare class ScheduleUnpublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private scheduleAction;
+    private accessControl;
+    private getModelUseCase;
+    constructor(scheduleAction: ScheduleActionUseCase.Interface, accessControl: AccessControl.Interface, getModelUseCase: GetModelUseCase.Interface);
+    execute(params: UseCaseAbstraction.Params): UseCaseAbstraction.Result;
+}
+export declare const ScheduleUnpublishEntryUseCase: typeof ScheduleUnpublishEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IScheduleUnpublishEntryUseCase>;
+};
+export {};

package/features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.js

@@ -0,0 +1,47 @@
+import { ScheduleUnpublishEntryUseCase } from "./abstractions.js";
+import { ScheduleActionUseCase, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+import { Result } from "@webiny/feature/exports/api.js";
+import { AccessControl } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { EntryNotAuthorizedError } from "@webiny/api-headless-cms/domain/contentEntry/errors.js";
+class ScheduleUnpublishEntryUseCaseImpl {
+    constructor(scheduleAction, accessControl, getModelUseCase){
+        this.scheduleAction = scheduleAction;
+        this.accessControl = accessControl;
+        this.getModelUseCase = getModelUseCase;
+    }
+    async execute(params) {
+        const { model: initialModel, scheduleFor, tenant, id } = params;
+        const modelResult = await this.getModelUseCase.execute(initialModel.modelId);
+        if (modelResult.isFail()) return Result.fail(modelResult.error);
+        const model = modelResult.value;
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            pw: "u"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const scheduleResult = await this.scheduleAction.execute({
+            namespace: createNamespace(model),
+            actionType: ScheduledActionTypeUnpublish,
+            scheduleFor,
+            tenant,
+            targetId: id
+        });
+        if (scheduleResult.isFail()) return Result.fail(scheduleResult.error);
+        return Result.ok({
+            scheduledAction: scheduleResult.value
+        });
+    }
+}
+const ScheduleUnpublishEntryUseCase_ScheduleUnpublishEntryUseCase = ScheduleUnpublishEntryUseCase.createImplementation({
+    implementation: ScheduleUnpublishEntryUseCaseImpl,
+    dependencies: [
+        ScheduleActionUseCase,
+        AccessControl,
+        GetModelUseCase
+    ]
+});
+export { ScheduleUnpublishEntryUseCase_ScheduleUnpublishEntryUseCase as ScheduleUnpublishEntryUseCase };
+
+//# sourceMappingURL=ScheduleUnpublishEntryUseCase.js.map

package/features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.js","sources":["../../../src/features/ScheduleUnpublishEntryUseCase/ScheduleUnpublishEntryUseCase.ts"],"sourcesContent":["import { ScheduleUnpublishEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport {\n    ScheduleActionUseCase,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\nimport { Result } from \"@webiny/feature/exports/api.js\";\nimport { AccessControl } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { EntryNotAuthorizedError } from \"@webiny/api-headless-cms/domain/contentEntry/errors.js\";\n\nclass ScheduleUnpublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private scheduleAction: ScheduleActionUseCase.Interface,\n        private accessControl: AccessControl.Interface,\n        private getModelUseCase: GetModelUseCase.Interface\n    ) {}\n\n    public async execute(params: UseCaseAbstraction.Params): UseCaseAbstraction.Result {\n        const { model: initialModel, scheduleFor, tenant, id } = params;\n\n        const modelResult = await this.getModelUseCase.execute(initialModel.modelId);\n        if (modelResult.isFail()) {\n            return Result.fail(modelResult.error as any);\n        }\n        const model = modelResult.value;\n\n        const canAccess = await this.accessControl.canAccessEntry({ model, pw: \"u\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model) as any);\n        }\n\n        const scheduleResult = await this.scheduleAction.execute({\n            namespace: createNamespace(model),\n            actionType: ScheduledActionTypeUnpublish,\n            scheduleFor,\n            tenant,\n            targetId: id\n        });\n        if (scheduleResult.isFail()) {\n            return Result.fail(scheduleResult.error);\n        }\n        return Result.ok({\n            scheduledAction: scheduleResult.value\n        });\n    }\n}\n\nexport const ScheduleUnpublishEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ScheduleUnpublishEntryUseCaseImpl,\n    dependencies: [ScheduleActionUseCase, AccessControl, GetModelUseCase]\n});\n"],"names":["ScheduleUnpublishEntryUseCaseImpl","scheduleAction","accessControl","getModelUseCase","params","initialModel","scheduleFor","tenant","id","modelResult","Result","model","canAccess","EntryNotAuthorizedError","scheduleResult","createNamespace","ScheduledActionTypeUnpublish","ScheduleUnpublishEntryUseCase","UseCaseAbstraction","ScheduleActionUseCase","AccessControl","GetModelUseCase"],"mappings":";;;;;;;AAWA,MAAMA;IACF,YACYC,cAA+C,EAC/CC,aAAsC,EACtCC,eAA0C,CACpD;aAHUF,cAAc,GAAdA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAa,QAAQC,MAAiC,EAA6B;QAC/E,MAAM,EAAE,OAAOC,YAAY,EAAEC,WAAW,EAAEC,MAAM,EAAEC,EAAE,EAAE,GAAGJ;QAEzD,MAAMK,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACJ,aAAa,OAAO;QAC3E,IAAII,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAExC,MAAME,QAAQF,YAAY,KAAK;QAE/B,MAAMG,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAED;YAAO,IAAI;QAAI;QAC3E,IAAI,CAACC,WACD,OAAOF,OAAO,IAAI,CAACG,wBAAwB,SAAS,CAACF;QAGzD,MAAMG,iBAAiB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;YACrD,WAAWC,gBAAgBJ;YAC3B,YAAYK;YACZV;YACAC;YACA,UAAUC;QACd;QACA,IAAIM,eAAe,MAAM,IACrB,OAAOJ,OAAO,IAAI,CAACI,eAAe,KAAK;QAE3C,OAAOJ,OAAO,EAAE,CAAC;YACb,iBAAiBI,eAAe,KAAK;QACzC;IACJ;AACJ;AAEO,MAAMG,8DAAgCC,8BAAAA,oBAAuC,CAAC;IACjF,gBAAgBlB;IAChB,cAAc;QAACmB;QAAuBC;QAAeC;KAAgB;AACzE"}

package/features/ScheduleUnpublishEntryUseCase/abstractions.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import type { IScheduledAction, ScheduleActionError } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IScheduleUnpublishEntryUseCaseParams {
+    id: string;
+    model: Pick<CmsModel, "modelId">;
+    tenant: string;
+    scheduleFor: Date;
+}
+export interface IScheduleUnpublishEntryUseCaseResult {
+    scheduledAction: IScheduledAction;
+}
+export type IScheduleUnpublishEntryUseCaseResponse = Promise<Result<IScheduleUnpublishEntryUseCaseResult, ScheduleActionError>>;
+export interface IScheduleUnpublishEntryUseCase {
+    execute(params: IScheduleUnpublishEntryUseCaseParams): IScheduleUnpublishEntryUseCaseResponse;
+}
+/** Schedule an entry for future unpublishing. */
+export declare const ScheduleUnpublishEntryUseCase: import("@webiny/di").Abstraction<IScheduleUnpublishEntryUseCase>;
+export declare namespace ScheduleUnpublishEntryUseCase {
+    type Interface = IScheduleUnpublishEntryUseCase;
+    type Error = ScheduleActionError;
+    type Params = IScheduleUnpublishEntryUseCaseParams;
+    type Result = IScheduleUnpublishEntryUseCaseResponse;
+}

package/features/ScheduleUnpublishEntryUseCase/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ScheduleUnpublishEntryUseCase = createAbstraction("CmsScheduler/ScheduleUnpublishEntryUseCase");
+export { ScheduleUnpublishEntryUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ScheduleUnpublishEntryUseCase/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ScheduleUnpublishEntryUseCase/abstractions.js","sources":["../../../src/features/ScheduleUnpublishEntryUseCase/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type {\n    IScheduledAction,\n    ScheduleActionError\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IScheduleUnpublishEntryUseCaseParams {\n    id: string;\n    model: Pick<CmsModel, \"modelId\">;\n    tenant: string;\n    scheduleFor: Date;\n}\n\nexport interface IScheduleUnpublishEntryUseCaseResult {\n    scheduledAction: IScheduledAction;\n}\n\nexport type IScheduleUnpublishEntryUseCaseResponse = Promise<\n    Result<IScheduleUnpublishEntryUseCaseResult, ScheduleActionError>\n>;\n\nexport interface IScheduleUnpublishEntryUseCase {\n    execute(params: IScheduleUnpublishEntryUseCaseParams): IScheduleUnpublishEntryUseCaseResponse;\n}\n\n/** Schedule an entry for future unpublishing. */\nexport const ScheduleUnpublishEntryUseCase = createAbstraction<IScheduleUnpublishEntryUseCase>(\n    \"CmsScheduler/ScheduleUnpublishEntryUseCase\"\n);\n\nexport namespace ScheduleUnpublishEntryUseCase {\n    export type Interface = IScheduleUnpublishEntryUseCase;\n    export type Error = ScheduleActionError;\n    export type Params = IScheduleUnpublishEntryUseCaseParams;\n    export type Result = IScheduleUnpublishEntryUseCaseResponse;\n}\n"],"names":["ScheduleUnpublishEntryUseCase","createAbstraction"],"mappings":";AA2BO,MAAMA,gCAAgCC,kBACzC"}

package/features/UnpublishActionHandler/UnpublishEntryActionHandler.d.ts

@@ -0,0 +1,30 @@
+import { type IScheduledAction, ScheduledActionHandler } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetPublishedEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds";
+import { UnpublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry";
+import type { IScheduledActionPayload } from "../../types.js";
+import type { ScheduledActionType } from "@webiny/api-scheduler/shared/abstractions.js";
+/**
+ * Handler for unpublishing CMS entries
+ *
+ * Handles the "Unpublish" action for CMS entries with namespace pattern: Cms/Entry/{modelId}
+ *
+ * Unpublishing logic:
+ * 1. If entry is not published -> nothing to do (warn)
+ * 2. If target entry is published (same revision) -> unpublish it
+ * 3. If a different revision is published -> unpublish it anyway
+ */
+declare class UnpublishEntryActionHandlerImpl implements ScheduledActionHandler.Interface {
+    private getModelUseCase;
+    private getEntryByIdUseCase;
+    private getPublishedEntriesByIdsUseCase;
+    private unpublishEntryUseCase;
+    constructor(getModelUseCase: GetModelUseCase.Interface, getEntryByIdUseCase: GetEntryByIdUseCase.Interface, getPublishedEntriesByIdsUseCase: GetPublishedEntriesByIdsUseCase.Interface, unpublishEntryUseCase: UnpublishEntryUseCase.Interface);
+    canHandle(namespace: string, actionType: ScheduledActionType): boolean;
+    handle(action: IScheduledAction<IScheduledActionPayload>): Promise<void>;
+}
+export declare const UnpublishEntryActionHandler: typeof UnpublishEntryActionHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/shared/abstractions.js").IScheduledActionHandler>;
+};
+export {};

package/features/UnpublishActionHandler/UnpublishEntryActionHandler.js

@@ -0,0 +1,69 @@
+import { ScheduledActionHandler, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetPublishedEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds";
+import { UnpublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry";
+import { extractModelIdFromNamespace } from "../../utils/namespace.js";
+class UnpublishEntryActionHandlerImpl {
+    constructor(getModelUseCase, getEntryByIdUseCase, getPublishedEntriesByIdsUseCase, unpublishEntryUseCase){
+        this.getModelUseCase = getModelUseCase;
+        this.getEntryByIdUseCase = getEntryByIdUseCase;
+        this.getPublishedEntriesByIdsUseCase = getPublishedEntriesByIdsUseCase;
+        this.unpublishEntryUseCase = unpublishEntryUseCase;
+    }
+    canHandle(namespace, actionType) {
+        const modelId = extractModelIdFromNamespace(namespace);
+        if (!modelId) return false;
+        return actionType === ScheduledActionTypeUnpublish;
+    }
+    async handle(action) {
+        const { payload } = action;
+        const modelId = payload.modelId;
+        const modelResult = await this.getModelUseCase.execute(modelId);
+        if (modelResult.isFail()) {
+            console.error(`Failed to get model "${modelId}" for scheduled unpublish action:`, modelResult.error);
+            throw new Error(`Model not found: ${modelId}`);
+        }
+        const model = modelResult.value;
+        const targetEntryResult = await this.getEntryByIdUseCase.execute(model, action.targetId);
+        if (targetEntryResult.isFail()) {
+            console.error(`Failed to get entry "${action.targetId}" for scheduled unpublish action:`, targetEntryResult.error);
+            throw new Error(`Entry not found: ${action.targetId}`);
+        }
+        const targetEntry = targetEntryResult.value;
+        const publishedEntriesResult = await this.getPublishedEntriesByIdsUseCase.execute(model, [
+            targetEntry.id
+        ]);
+        if (publishedEntriesResult.isFail()) {
+            console.error(`Failed to get published entries for "${targetEntry.id}":`, publishedEntriesResult.error);
+            throw new Error("Failed to check published entries");
+        }
+        const [publishedTargetEntry] = publishedEntriesResult.value;
+        if (!publishedTargetEntry) return void console.warn(`Entry "${action.targetId}" is not published, nothing to unpublish.`);
+        if (publishedTargetEntry.id === action.targetId) {
+            const unpublishResult = await this.unpublishEntryUseCase.execute(model, action.targetId);
+            if (unpublishResult.isFail()) {
+                console.error(`Failed to unpublish entry "${action.targetId}":`, unpublishResult.error);
+                throw new Error(`Failed to unpublish entry: ${action.targetId}`);
+            }
+            return;
+        }
+        const unpublishResult = await this.unpublishEntryUseCase.execute(model, publishedTargetEntry.id);
+        if (unpublishResult.isFail()) {
+            console.error(`Failed to unpublish published revision "${publishedTargetEntry.id}":`, unpublishResult.error);
+            throw new Error(`Failed to unpublish entry: ${publishedTargetEntry.id}`);
+        }
+    }
+}
+const UnpublishEntryActionHandler = ScheduledActionHandler.createImplementation({
+    implementation: UnpublishEntryActionHandlerImpl,
+    dependencies: [
+        GetModelUseCase,
+        GetEntryByIdUseCase,
+        GetPublishedEntriesByIdsUseCase,
+        UnpublishEntryUseCase
+    ]
+});
+export { UnpublishEntryActionHandler };
+
+//# sourceMappingURL=UnpublishEntryActionHandler.js.map

package/features/UnpublishActionHandler/UnpublishEntryActionHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnpublishActionHandler/UnpublishEntryActionHandler.js","sources":["../../../src/features/UnpublishActionHandler/UnpublishEntryActionHandler.ts"],"sourcesContent":["import {\n    type IScheduledAction,\n    ScheduledActionHandler,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { GetPublishedEntriesByIdsUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds\";\nimport { UnpublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry\";\nimport type { IScheduledActionPayload } from \"~/types.js\";\nimport { extractModelIdFromNamespace } from \"~/utils/namespace.js\";\nimport type { ScheduledActionType } from \"@webiny/api-scheduler/shared/abstractions.js\";\n\n/**\n * Handler for unpublishing CMS entries\n *\n * Handles the \"Unpublish\" action for CMS entries with namespace pattern: Cms/Entry/{modelId}\n *\n * Unpublishing logic:\n * 1. If entry is not published -> nothing to do (warn)\n * 2. If target entry is published (same revision) -> unpublish it\n * 3. If a different revision is published -> unpublish it anyway\n */\nclass UnpublishEntryActionHandlerImpl implements ScheduledActionHandler.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface,\n        private getPublishedEntriesByIdsUseCase: GetPublishedEntriesByIdsUseCase.Interface,\n        private unpublishEntryUseCase: UnpublishEntryUseCase.Interface\n    ) {}\n\n    canHandle(namespace: string, actionType: ScheduledActionType): boolean {\n        const modelId = extractModelIdFromNamespace(namespace);\n        if (!modelId) {\n            return false;\n        }\n        return actionType === ScheduledActionTypeUnpublish;\n    }\n\n    async handle(action: IScheduledAction<IScheduledActionPayload>): Promise<void> {\n        const { payload } = action;\n\n        const modelId = payload.modelId as string;\n\n        // Fetch the model\n        const modelResult = await this.getModelUseCase.execute(modelId);\n        if (modelResult.isFail()) {\n            console.error(\n                `Failed to get model \"${modelId}\" for scheduled unpublish action:`,\n                modelResult.error\n            );\n            throw new Error(`Model not found: ${modelId}`);\n        }\n\n        const model = modelResult.value;\n\n        // Fetch the target entry\n        const targetEntryResult = await this.getEntryByIdUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, action.targetId);\n        if (targetEntryResult.isFail()) {\n            console.error(\n                `Failed to get entry \"${action.targetId}\" for scheduled unpublish action:`,\n                targetEntryResult.error\n            );\n            throw new Error(`Entry not found: ${action.targetId}`);\n        }\n\n        const targetEntry = targetEntryResult.value;\n\n        // Get published entries\n        const publishedEntriesResult = await this.getPublishedEntriesByIdsUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, [targetEntry.id]);\n\n        if (publishedEntriesResult.isFail()) {\n            console.error(\n                `Failed to get published entries for \"${targetEntry.id}\":`,\n                publishedEntriesResult.error\n            );\n            throw new Error(`Failed to check published entries`);\n        }\n\n        const [publishedTargetEntry] = publishedEntriesResult.value;\n\n        /**\n         * Scenario 1: Entry is not published -> nothing to do\n         */\n        if (!publishedTargetEntry) {\n            console.warn(`Entry \"${action.targetId}\" is not published, nothing to unpublish.`);\n            return;\n        }\n\n        /**\n         * Scenario 2: Target entry is published (same revision) -> unpublish it\n         */\n        if (publishedTargetEntry.id === action.targetId) {\n            const unpublishResult = await this.unpublishEntryUseCase.execute<\n                IScheduledAction<IScheduledActionPayload>\n            >(model, action.targetId);\n            if (unpublishResult.isFail()) {\n                console.error(\n                    `Failed to unpublish entry \"${action.targetId}\":`,\n                    unpublishResult.error\n                );\n                throw new Error(`Failed to unpublish entry: ${action.targetId}`);\n            }\n            return;\n        }\n\n        /**\n         * Scenario 3: A different revision is published -> unpublish it anyway\n         * TODO: Determine if we really want to unpublish an entry which does not match the target ID\n         */\n        const unpublishResult = await this.unpublishEntryUseCase.execute<\n            IScheduledAction<IScheduledActionPayload>\n        >(model, publishedTargetEntry.id);\n        if (unpublishResult.isFail()) {\n            console.error(\n                `Failed to unpublish published revision \"${publishedTargetEntry.id}\":`,\n                unpublishResult.error\n            );\n            throw new Error(`Failed to unpublish entry: ${publishedTargetEntry.id}`);\n        }\n    }\n}\n\nexport const UnpublishEntryActionHandler = ScheduledActionHandler.createImplementation({\n    implementation: UnpublishEntryActionHandlerImpl,\n    dependencies: [\n        GetModelUseCase,\n        GetEntryByIdUseCase,\n        GetPublishedEntriesByIdsUseCase,\n        UnpublishEntryUseCase\n    ]\n});\n"],"names":["UnpublishEntryActionHandlerImpl","getModelUseCase","getEntryByIdUseCase","getPublishedEntriesByIdsUseCase","unpublishEntryUseCase","namespace","actionType","modelId","extractModelIdFromNamespace","ScheduledActionTypeUnpublish","action","payload","modelResult","console","Error","model","targetEntryResult","targetEntry","publishedEntriesResult","publishedTargetEntry","unpublishResult","UnpublishEntryActionHandler","ScheduledActionHandler","GetModelUseCase","GetEntryByIdUseCase","GetPublishedEntriesByIdsUseCase","UnpublishEntryUseCase"],"mappings":";;;;;;AAuBA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,mBAAkD,EAClDC,+BAA0E,EAC1EC,qBAAsD,CAChE;aAJUH,eAAe,GAAfA;aACAC,mBAAmB,GAAnBA;aACAC,+BAA+B,GAA/BA;aACAC,qBAAqB,GAArBA;IACT;IAEH,UAAUC,SAAiB,EAAEC,UAA+B,EAAW;QACnE,MAAMC,UAAUC,4BAA4BH;QAC5C,IAAI,CAACE,SACD,OAAO;QAEX,OAAOD,eAAeG;IAC1B;IAEA,MAAM,OAAOC,MAAiD,EAAiB;QAC3E,MAAM,EAAEC,OAAO,EAAE,GAAGD;QAEpB,MAAMH,UAAUI,QAAQ,OAAO;QAG/B,MAAMC,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACL;QACvD,IAAIK,YAAY,MAAM,IAAI;YACtBC,QAAQ,KAAK,CACT,CAAC,qBAAqB,EAAEN,QAAQ,iCAAiC,CAAC,EAClEK,YAAY,KAAK;YAErB,MAAM,IAAIE,MAAM,CAAC,iBAAiB,EAAEP,SAAS;QACjD;QAEA,MAAMQ,QAAQH,YAAY,KAAK;QAG/B,MAAMI,oBAAoB,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAE9DD,OAAOL,OAAO,QAAQ;QACxB,IAAIM,kBAAkB,MAAM,IAAI;YAC5BH,QAAQ,KAAK,CACT,CAAC,qBAAqB,EAAEH,OAAO,QAAQ,CAAC,iCAAiC,CAAC,EAC1EM,kBAAkB,KAAK;YAE3B,MAAM,IAAIF,MAAM,CAAC,iBAAiB,EAAEJ,OAAO,QAAQ,EAAE;QACzD;QAEA,MAAMO,cAAcD,kBAAkB,KAAK;QAG3C,MAAME,yBAAyB,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,CAE/EH,OAAO;YAACE,YAAY,EAAE;SAAC;QAEzB,IAAIC,uBAAuB,MAAM,IAAI;YACjCL,QAAQ,KAAK,CACT,CAAC,qCAAqC,EAAEI,YAAY,EAAE,CAAC,EAAE,CAAC,EAC1DC,uBAAuB,KAAK;YAEhC,MAAM,IAAIJ,MAAM;QACpB;QAEA,MAAM,CAACK,qBAAqB,GAAGD,uBAAuB,KAAK;QAK3D,IAAI,CAACC,sBAAsB,YACvBN,QAAQ,IAAI,CAAC,CAAC,OAAO,EAAEH,OAAO,QAAQ,CAAC,yCAAyC,CAAC;QAOrF,IAAIS,qBAAqB,EAAE,KAAKT,OAAO,QAAQ,EAAE;YAC7C,MAAMU,kBAAkB,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAE9DL,OAAOL,OAAO,QAAQ;YACxB,IAAIU,gBAAgB,MAAM,IAAI;gBAC1BP,QAAQ,KAAK,CACT,CAAC,2BAA2B,EAAEH,OAAO,QAAQ,CAAC,EAAE,CAAC,EACjDU,gBAAgB,KAAK;gBAEzB,MAAM,IAAIN,MAAM,CAAC,2BAA2B,EAAEJ,OAAO,QAAQ,EAAE;YACnE;YACA;QACJ;QAMA,MAAMU,kBAAkB,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAE9DL,OAAOI,qBAAqB,EAAE;QAChC,IAAIC,gBAAgB,MAAM,IAAI;YAC1BP,QAAQ,KAAK,CACT,CAAC,wCAAwC,EAAEM,qBAAqB,EAAE,CAAC,EAAE,CAAC,EACtEC,gBAAgB,KAAK;YAEzB,MAAM,IAAIN,MAAM,CAAC,2BAA2B,EAAEK,qBAAqB,EAAE,EAAE;QAC3E;IACJ;AACJ;AAEO,MAAME,8BAA8BC,uBAAuB,oBAAoB,CAAC;IACnF,gBAAgBtB;IAChB,cAAc;QACVuB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/permissions/CmsSchedulerPermissions.d.ts

@@ -0,0 +1,13 @@
+import { SchedulerPermissions } from "@webiny/api-scheduler/features/permissions/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+declare class CmsSchedulerPermissionsImpl implements SchedulerPermissions.Interface {
+    private identityContext;
+    constructor(identityContext: IdentityContext.Interface);
+    canHandle(namespace: string): boolean;
+    canRead(): Promise<boolean>;
+    onlyOwnRecords(): Promise<boolean>;
+}
+export declare const CmsSchedulerPermissions: typeof CmsSchedulerPermissionsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-scheduler/features/permissions/abstractions.js").ISchedulerPermissions>;
+};
+export {};

package/features/permissions/CmsSchedulerPermissions.js

@@ -0,0 +1,31 @@
+import { SchedulerPermissions } from "@webiny/api-scheduler/features/permissions/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { CMS_NAMESPACE } from "../../utils/namespace.js";
+class CmsSchedulerPermissionsImpl {
+    constructor(identityContext){
+        this.identityContext = identityContext;
+    }
+    canHandle(namespace) {
+        return namespace.startsWith(CMS_NAMESPACE);
+    }
+    async canRead() {
+        if (await this.identityContext.hasFullAccess()) return true;
+        const permissions = await this.identityContext.getPermissions("cms.contentEntry");
+        return permissions.length > 0;
+    }
+    async onlyOwnRecords() {
+        if (await this.identityContext.hasFullAccess()) return false;
+        const permissions = await this.identityContext.getPermissions("cms.contentEntry");
+        if (!permissions.length) return false;
+        return !permissions.some((p)=>!p.own);
+    }
+}
+const CmsSchedulerPermissions = SchedulerPermissions.createImplementation({
+    implementation: CmsSchedulerPermissionsImpl,
+    dependencies: [
+        IdentityContext
+    ]
+});
+export { CmsSchedulerPermissions };
+
+//# sourceMappingURL=CmsSchedulerPermissions.js.map

package/features/permissions/CmsSchedulerPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/permissions/CmsSchedulerPermissions.js","sources":["../../../src/features/permissions/CmsSchedulerPermissions.ts"],"sourcesContent":["import { SchedulerPermissions } from \"@webiny/api-scheduler/features/permissions/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { CMS_NAMESPACE } from \"~/utils/namespace.js\";\n\nclass CmsSchedulerPermissionsImpl implements SchedulerPermissions.Interface {\n    constructor(private identityContext: IdentityContext.Interface) {}\n\n    canHandle(namespace: string): boolean {\n        return namespace.startsWith(CMS_NAMESPACE);\n    }\n\n    async canRead(): Promise<boolean> {\n        if (await this.identityContext.hasFullAccess()) {\n            return true;\n        }\n        const permissions = await this.identityContext.getPermissions(\"cms.contentEntry\");\n        return permissions.length > 0;\n    }\n\n    async onlyOwnRecords(): Promise<boolean> {\n        if (await this.identityContext.hasFullAccess()) {\n            return false;\n        }\n        const permissions = await this.identityContext.getPermissions(\"cms.contentEntry\");\n        if (!permissions.length) {\n            return false;\n        }\n        return !permissions.some((p: any) => !p.own);\n    }\n}\n\nexport const CmsSchedulerPermissions = SchedulerPermissions.createImplementation({\n    implementation: CmsSchedulerPermissionsImpl,\n    dependencies: [IdentityContext]\n});\n"],"names":["CmsSchedulerPermissionsImpl","identityContext","namespace","CMS_NAMESPACE","permissions","p","CmsSchedulerPermissions","SchedulerPermissions","IdentityContext"],"mappings":";;;AAIA,MAAMA;IACF,YAAoBC,eAA0C,CAAE;aAA5CA,eAAe,GAAfA;IAA6C;IAEjE,UAAUC,SAAiB,EAAW;QAClC,OAAOA,UAAU,UAAU,CAACC;IAChC;IAEA,MAAM,UAA4B;QAC9B,IAAI,MAAM,IAAI,CAAC,eAAe,CAAC,aAAa,IACxC,OAAO;QAEX,MAAMC,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC;QAC9D,OAAOA,YAAY,MAAM,GAAG;IAChC;IAEA,MAAM,iBAAmC;QACrC,IAAI,MAAM,IAAI,CAAC,eAAe,CAAC,aAAa,IACxC,OAAO;QAEX,MAAMA,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC;QAC9D,IAAI,CAACA,YAAY,MAAM,EACnB,OAAO;QAEX,OAAO,CAACA,YAAY,IAAI,CAAC,CAACC,IAAW,CAACA,EAAE,GAAG;IAC/C;AACJ;AAEO,MAAMC,0BAA0BC,qBAAqB,oBAAoB,CAAC;IAC7E,gBAAgBP;IAChB,cAAc;QAACQ;KAAgB;AACnC"}

package/index.d.ts

@@ -0,0 +1 @@
+export { CmsSchedulerFeature } from "./CmsSchedulerFeature.js";

package/index.js

@@ -0,0 +1 @@
+export { CmsSchedulerFeature } from "./CmsSchedulerFeature.js";

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@webiny/api-headless-cms-scheduler",
+	"version": "0.0.0-unstable.0156a4c312",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "Schedule for Webiny Headless CMS",
+	"keywords": [
+		"api-headless-cms-scheduler:base"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-headless-cms-scheduler"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-headless-cms": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-scheduler": "0.0.0-unstable.0156a4c312",
+		"@webiny/feature": "0.0.0-unstable.0156a4c312"
+	},
+	"devDependencies": {
+		"@webiny/api-core": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-headless-cms-testing": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-opensearch": "0.0.0-unstable.0156a4c312",
+		"@webiny/build-tools": "0.0.0-unstable.0156a4c312",
+		"@webiny/wcp": "0.0.0-unstable.0156a4c312",
+		"typescript": "7.0.2",
+		"vitest": "5.0.5"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/types.d.ts

@@ -0,0 +1,4 @@
+import type { INamespaceHandlerResult } from "@webiny/api-scheduler/features/NamespaceHandler/abstractions.js";
+export interface IScheduledActionPayload extends INamespaceHandlerResult {
+    modelId: string;
+}

package/utils/namespace.d.ts

@@ -0,0 +1,4 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export declare const CMS_NAMESPACE = "Cms/Entry/";
+export declare const createNamespace: (model: Pick<CmsModel, "modelId">) => string;
+export declare const extractModelIdFromNamespace: (namespace: string) => string | null;

package/utils/namespace.js

@@ -0,0 +1,9 @@
+const CMS_NAMESPACE = "Cms/Entry/";
+const createNamespace = (model)=>`${CMS_NAMESPACE}${model.modelId}`;
+const extractModelIdFromNamespace = (namespace)=>{
+    if (!namespace.startsWith(CMS_NAMESPACE)) return null;
+    return namespace.substring(CMS_NAMESPACE.length) || null;
+};
+export { CMS_NAMESPACE, createNamespace, extractModelIdFromNamespace };
+
+//# sourceMappingURL=namespace.js.map

package/utils/namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/namespace.js","sources":["../../src/utils/namespace.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport const CMS_NAMESPACE = \"Cms/Entry/\";\n\nexport const createNamespace = (model: Pick<CmsModel, \"modelId\">) => {\n    return `${CMS_NAMESPACE}${model.modelId}`;\n};\n\nexport const extractModelIdFromNamespace = (namespace: string): string | null => {\n    if (!namespace.startsWith(CMS_NAMESPACE)) {\n        return null;\n    }\n    return namespace.substring(CMS_NAMESPACE.length) || null;\n};\n"],"names":["CMS_NAMESPACE","createNamespace","model","extractModelIdFromNamespace","namespace"],"mappings":"AAEO,MAAMA,gBAAgB;AAEtB,MAAMC,kBAAkB,CAACC,QACrB,GAAGF,gBAAgBE,MAAM,OAAO,EAAE;AAGtC,MAAMC,8BAA8B,CAACC;IACxC,IAAI,CAACA,UAAU,UAAU,CAACJ,gBACtB,OAAO;IAEX,OAAOI,UAAU,SAAS,CAACJ,cAAc,MAAM,KAAK;AACxD"}