@webiny/api-headless-cms-scheduler 0.0.0-unstable.e53eceafb5 → 0.0.0-unstable.e6f0dc8ca7

package/README.md

@@ -1,15 +1,11 @@
-# @webiny/api-headless-cms-schedule
-[![](https://img.shields.io/npm/dw/@webiny/api-headless-cms-schedule.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms-schedule) 
-[![](https://img.shields.io/npm/v/@webiny/api-headless-cms-schedule.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms-schedule)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
- 
-## Install
-```
-npm install --save @webiny/api-headless-cms-schedule
-```
-
-Or if you prefer yarn: 
-```
-yarn add @webiny/api-headless-cms-schedule
-```
+# @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/context.d.ts

@@ -1,7 +1,2 @@
-import { ContextPlugin } from "@webiny/api/index.js";
-import type { SchedulerClient, SchedulerClientConfig } from "@webiny/aws-sdk/client-scheduler/index.js";
-import type { ScheduleContext } from "./types.js";
-export interface ICreateHeadlessCmsSchedulerContextParams {
-    getClient(config?: SchedulerClientConfig): Pick<SchedulerClient, "send">;
-}
-export declare const createHeadlessCmsScheduleContext: (params: ICreateHeadlessCmsSchedulerContextParams) => ContextPlugin<ScheduleContext>;
+import { ContextPlugin } from "@webiny/api";
+export declare const createHeadlessCmsScheduleContext: () => ContextPlugin<import("@webiny/api/types").Context>;

package/context.js

@@ -1,63 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createHeadlessCmsScheduleContext = void 0;
-var _index = require("@webiny/api/index.js");
-var _SchedulerService = require("./service/SchedulerService.js");
-var _manifest = require("./manifest.js");
-var _utils = require("@webiny/utils");
-var _createScheduler = require("./scheduler/createScheduler.js");
-var _handlerGraphql = require("@webiny/handler-graphql");
-var _constants = require("./constants.js");
-var _apiHeadlessCms = require("@webiny/api-headless-cms");
-const createHeadlessCmsScheduleContext = params => {
-  return new _index.ContextPlugin(async context => {
-    /**
-     * If the Headless CMS is not ready, it means the system is not fully installed yet.
-     * We do not want to continue because it would break anyway.
-     */
-    const ready = await (0, _apiHeadlessCms.isHeadlessCmsReady)(context);
-    if (!ready) {
-      return;
-    }
-    const manifest = await (0, _manifest.getManifest)({
-      client: context.db.driver.getClient()
-    });
-    if (manifest.error) {
-      console.error(manifest.error.message);
-      console.log((0, _utils.convertException)(manifest.error, ["message"]));
-      console.info("Scheduler not attached.");
-      return;
-    }
-    const service = (0, _SchedulerService.createSchedulerService)({
-      getClient: params.getClient,
-      config: {
-        lambdaArn: manifest.data.lambdaArn,
-        roleArn: manifest.data.roleArn
-      }
-    });
-    let scheduleModel;
-    try {
-      scheduleModel = await context.cms.getModel(_constants.SCHEDULE_MODEL_ID);
-    } catch (ex) {
-      if (ex.code === "NOT_FOUND" || ex instanceof _handlerGraphql.NotFoundError) {
-        console.error(`Schedule model "${_constants.SCHEDULE_MODEL_ID}" not found.`);
-        return;
-      }
-      console.error(`Error while fetching schedule model "${_constants.SCHEDULE_MODEL_ID}".`);
-      console.log((0, _utils.convertException)(ex));
-      return;
-    }
-    context.cms.scheduler = await (0, _createScheduler.createScheduler)({
-      cms: context.cms,
-      security: context.security,
-      service,
-      scheduleModel
-    });
+import { ContextPlugin } from "@webiny/api";
+import { CancelScheduledActionOnEntryChangeFeature } from "./features/CancelScheduledActionOnEntryChange/feature.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";
+export const createHeadlessCmsScheduleContext = () => {
+  return new ContextPlugin(async context => {
+    context.container.register(NamespaceHandler);
+    context.container.register(PublishEntryActionHandler);
+    context.container.register(UnpublishEntryActionHandler);
+    context.container.register(SchedulePublishEntryUseCase);
+    context.container.register(ScheduleUnpublishEntryUseCase);
+    CancelScheduledActionOnEntryChangeFeature.register(context.container);
   });
 };
-exports.createHeadlessCmsScheduleContext = createHeadlessCmsScheduleContext;
 
 //# sourceMappingURL=context.js.map

package/context.js.map

@@ -1 +1 @@
-{"version":3,"names":["_index","require","_SchedulerService","_manifest","_utils","_createScheduler","_handlerGraphql","_constants","_apiHeadlessCms","createHeadlessCmsScheduleContext","params","ContextPlugin","context","ready","isHeadlessCmsReady","manifest","getManifest","client","db","driver","getClient","error","console","message","log","convertException","info","service","createSchedulerService","config","lambdaArn","data","roleArn","scheduleModel","cms","getModel","SCHEDULE_MODEL_ID","ex","code","NotFoundError","scheduler","createScheduler","security","exports"],"sources":["context.ts"],"sourcesContent":["import { ContextPlugin } from \"@webiny/api/index.js\";\nimport type {\n    SchedulerClient,\n    SchedulerClientConfig\n} from \"@webiny/aws-sdk/client-scheduler/index.js\";\nimport { createSchedulerService } from \"~/service/SchedulerService.js\";\nimport { getManifest } from \"~/manifest.js\";\nimport { convertException } from \"@webiny/utils\";\nimport type { ScheduleContext } from \"~/types.js\";\nimport { createScheduler } from \"./scheduler/createScheduler.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\nimport { SCHEDULE_MODEL_ID } from \"./constants.js\";\nimport { isHeadlessCmsReady } from \"@webiny/api-headless-cms\";\nimport type { DynamoDBDocument } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\n\nexport interface ICreateHeadlessCmsSchedulerContextParams {\n    getClient(config?: SchedulerClientConfig): Pick<SchedulerClient, \"send\">;\n}\n\nexport const createHeadlessCmsScheduleContext = (\n    params: ICreateHeadlessCmsSchedulerContextParams\n) => {\n    return new ContextPlugin<ScheduleContext>(async context => {\n        /**\n         * If the Headless CMS is not ready, it means the system is not fully installed yet.\n         * We do not want to continue because it would break anyway.\n         */\n        const ready = await isHeadlessCmsReady(context);\n        if (!ready) {\n            return;\n        }\n        const manifest = await getManifest({\n            client: context.db.driver.getClient() as DynamoDBDocument\n        });\n        if (manifest.error) {\n            console.error(manifest.error.message);\n            console.log(convertException(manifest.error, [\"message\"]));\n            console.info(\"Scheduler not attached.\");\n            return;\n        }\n\n        const service = createSchedulerService({\n            getClient: params.getClient,\n            config: {\n                lambdaArn: manifest.data.lambdaArn,\n                roleArn: manifest.data.roleArn\n            }\n        });\n\n        let scheduleModel: CmsModel;\n        try {\n            scheduleModel = await context.cms.getModel(SCHEDULE_MODEL_ID);\n        } catch (ex) {\n            if (ex.code === \"NOT_FOUND\" || ex instanceof NotFoundError) {\n                console.error(`Schedule model \"${SCHEDULE_MODEL_ID}\" not found.`);\n                return;\n            }\n            console.error(`Error while fetching schedule model \"${SCHEDULE_MODEL_ID}\".`);\n            console.log(convertException(ex));\n            return;\n        }\n\n        context.cms.scheduler = await createScheduler({\n            cms: context.cms,\n            security: context.security,\n            service,\n            scheduleModel\n        });\n    });\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAEA,IAAAI,gBAAA,GAAAJ,OAAA;AAEA,IAAAK,eAAA,GAAAL,OAAA;AACA,IAAAM,UAAA,GAAAN,OAAA;AACA,IAAAO,eAAA,GAAAP,OAAA;AAOO,MAAMQ,gCAAgC,GACzCC,MAAgD,IAC/C;EACD,OAAO,IAAIC,oBAAa,CAAkB,MAAMC,OAAO,IAAI;IACvD;AACR;AACA;AACA;IACQ,MAAMC,KAAK,GAAG,MAAM,IAAAC,kCAAkB,EAACF,OAAO,CAAC;IAC/C,IAAI,CAACC,KAAK,EAAE;MACR;IACJ;IACA,MAAME,QAAQ,GAAG,MAAM,IAAAC,qBAAW,EAAC;MAC/BC,MAAM,EAAEL,OAAO,CAACM,EAAE,CAACC,MAAM,CAACC,SAAS,CAAC;IACxC,CAAC,CAAC;IACF,IAAIL,QAAQ,CAACM,KAAK,EAAE;MAChBC,OAAO,CAACD,KAAK,CAACN,QAAQ,CAACM,KAAK,CAACE,OAAO,CAAC;MACrCD,OAAO,CAACE,GAAG,CAAC,IAAAC,uBAAgB,EAACV,QAAQ,CAACM,KAAK,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;MAC1DC,OAAO,CAACI,IAAI,CAAC,yBAAyB,CAAC;MACvC;IACJ;IAEA,MAAMC,OAAO,GAAG,IAAAC,wCAAsB,EAAC;MACnCR,SAAS,EAAEV,MAAM,CAACU,SAAS;MAC3BS,MAAM,EAAE;QACJC,SAAS,EAAEf,QAAQ,CAACgB,IAAI,CAACD,SAAS;QAClCE,OAAO,EAAEjB,QAAQ,CAACgB,IAAI,CAACC;MAC3B;IACJ,CAAC,CAAC;IAEF,IAAIC,aAAuB;IAC3B,IAAI;MACAA,aAAa,GAAG,MAAMrB,OAAO,CAACsB,GAAG,CAACC,QAAQ,CAACC,4BAAiB,CAAC;IACjE,CAAC,CAAC,OAAOC,EAAE,EAAE;MACT,IAAIA,EAAE,CAACC,IAAI,KAAK,WAAW,IAAID,EAAE,YAAYE,6BAAa,EAAE;QACxDjB,OAAO,CAACD,KAAK,CAAC,mBAAmBe,4BAAiB,cAAc,CAAC;QACjE;MACJ;MACAd,OAAO,CAACD,KAAK,CAAC,wCAAwCe,4BAAiB,IAAI,CAAC;MAC5Ed,OAAO,CAACE,GAAG,CAAC,IAAAC,uBAAgB,EAACY,EAAE,CAAC,CAAC;MACjC;IACJ;IAEAzB,OAAO,CAACsB,GAAG,CAACM,SAAS,GAAG,MAAM,IAAAC,gCAAe,EAAC;MAC1CP,GAAG,EAAEtB,OAAO,CAACsB,GAAG;MAChBQ,QAAQ,EAAE9B,OAAO,CAAC8B,QAAQ;MAC1Bf,OAAO;MACPM;IACJ,CAAC,CAAC;EACN,CAAC,CAAC;AACN,CAAC;AAACU,OAAA,CAAAlC,gCAAA,GAAAA,gCAAA","ignoreList":[]}
+{"version":3,"names":["ContextPlugin","CancelScheduledActionOnEntryChangeFeature","NamespaceHandler","PublishEntryActionHandler","UnpublishEntryActionHandler","SchedulePublishEntryUseCase","ScheduleUnpublishEntryUseCase","createHeadlessCmsScheduleContext","context","container","register"],"sources":["context.ts"],"sourcesContent":["import { ContextPlugin } from \"@webiny/api\";\nimport { CancelScheduledActionOnEntryChangeFeature } from \"~/features/CancelScheduledActionOnEntryChange/feature.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 createHeadlessCmsScheduleContext = () => {\n    return new ContextPlugin(async context => {\n        context.container.register(NamespaceHandler);\n        context.container.register(PublishEntryActionHandler);\n        context.container.register(UnpublishEntryActionHandler);\n        context.container.register(SchedulePublishEntryUseCase);\n        context.container.register(ScheduleUnpublishEntryUseCase);\n\n        CancelScheduledActionOnEntryChangeFeature.register(context.container);\n    });\n};\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,aAAa;AAC3C,SAASC,yCAAyC;AAClD,SAASC,gBAAgB;AACzB,SAASC,yBAAyB;AAClC,SAASC,2BAA2B;AACpC,SAASC,2BAA2B;AACpC,SAASC,6BAA6B;AAEtC,OAAO,MAAMC,gCAAgC,GAAGA,CAAA,KAAM;EAClD,OAAO,IAAIP,aAAa,CAAC,MAAMQ,OAAO,IAAI;IACtCA,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACR,gBAAgB,CAAC;IAC5CM,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACP,yBAAyB,CAAC;IACrDK,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACN,2BAA2B,CAAC;IACvDI,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACL,2BAA2B,CAAC;IACvDG,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACJ,6BAA6B,CAAC;IAEzDL,yCAAyC,CAACS,QAAQ,CAACF,OAAO,CAACC,SAAS,CAAC;EACzE,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

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,4 @@
+export { SchedulePublishEntryUseCase } from "../../../features/SchedulePublishEntryUseCase/abstractions.js";
+export { ScheduleUnpublishEntryUseCase } from "../../../features/ScheduleUnpublishEntryUseCase/abstractions.js";
+
+//# sourceMappingURL=scheduler.js.map

package/exports/api/cms/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SchedulePublishEntryUseCase","ScheduleUnpublishEntryUseCase"],"sources":["scheduler.ts"],"sourcesContent":["export { SchedulePublishEntryUseCase } from \"~/features/SchedulePublishEntryUseCase/abstractions.js\";\nexport { ScheduleUnpublishEntryUseCase } from \"~/features/ScheduleUnpublishEntryUseCase/abstractions.js\";\n"],"mappings":"AAAA,SAASA,2BAA2B;AACpC,SAASC,6BAA6B","ignoreList":[]}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.d.ts

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

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EntryAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","CancelScheduledActionOnEntryDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","schedules","listSchedules","modelId","entryId","action","cancelRes","execute","isFail","actionsResult","limit","where","namespace","targetId_startsWith","value","items","CancelScheduledActionOnEntryDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnEntryDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry is deleted\n *\n * When a user deletes an entry, any scheduled publish/unpublish\n * actions for all of its revisions should be canceled since the entry\n * no longer exists.\n */\nclass CancelScheduledActionOnEntryDeleteHandlerImpl\n    implements EntryAfterDeleteEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const schedules = await this.listSchedules(model.modelId, entry.entryId);\n        for (const action of schedules) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // The entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n\n    private async listSchedules(modelId: string, entryId: string) {\n        const actionsResult = await this.listScheduledActions.execute({\n            limit: 10000,\n            where: {\n                namespace: createNamespace({ modelId }),\n                targetId_startsWith: `${entryId}#`\n            }\n        });\n\n        return actionsResult.value.items;\n    }\n}\n\nexport const CancelScheduledActionOnEntryDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,mEAAmE;AAChH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,6CAA6C,CAEnD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACC,aAAa,CAACJ,KAAK,CAACK,OAAO,EAAEN,KAAK,CAACO,OAAO,CAAC;IACxE,KAAK,MAAMC,MAAM,IAAIJ,SAAS,EAAE;MAC5B,MAAMK,SAAS,GAAG,MAAM,IAAI,CAACZ,qBAAqB,CAACa,OAAO,CAACF,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACE,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;EAEA,MAAcN,aAAaA,CAACC,OAAe,EAAEC,OAAe,EAAE;IAC1D,MAAMK,aAAa,GAAG,MAAM,IAAI,CAAChB,oBAAoB,CAACc,OAAO,CAAC;MAC1DG,KAAK,EAAE,KAAK;MACZC,KAAK,EAAE;QACHC,SAAS,EAAEtB,eAAe,CAAC;UAAEa;QAAQ,CAAC,CAAC;QACvCU,mBAAmB,EAAE,GAAGT,OAAO;MACnC;IACJ,CAAC,CAAC;IAEF,OAAOK,aAAa,CAACK,KAAK,CAACC,KAAK;EACpC;AACJ;AAEA,OAAO,MAAMC,8CAA8C,GACvD7B,4BAA4B,CAAC8B,oBAAoB,CAAC;EAC9CC,cAAc,EAAE3B,6CAA6C;EAC7D4B,YAAY,EAAE,CAAC9B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.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;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.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,49 @@
+import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+
+/**
+ * Cancels scheduled "publish" when an entry is manually published
+ *
+ * When a user manually publishes an entry, any scheduled publish
+ * action for that entry should be canceled since the manual action
+ * takes precedence.
+ */
+class CancelScheduledActionOnPublishEventHandlerImpl {
+  constructor(listScheduledActions, cancelScheduledAction) {
+    this.listScheduledActions = listScheduledActions;
+    this.cancelScheduledAction = cancelScheduledAction;
+  }
+  async handle(event) {
+    const {
+      entry,
+      model
+    } = event.payload;
+
+    // Skip private models
+    if (model.isPrivate) {
+      return;
+    }
+    const actionsResult = await this.listScheduledActions.execute({
+      where: {
+        namespace: createNamespace(model),
+        actionType: ScheduledActionTypePublish,
+        targetId: entry.id
+      }
+    });
+    const actions = actionsResult.value.items;
+    for (const action of actions) {
+      const cancelRes = await this.cancelScheduledAction.execute(action);
+      if (cancelRes.isFail()) {
+        // Silently ignore errors - this is non-critical cleanup.
+        // Even if a schedule runs on an already published action, nothing bad will happen.
+      }
+    }
+  }
+}
+export const CancelScheduledActionOnPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
+  implementation: CancelScheduledActionOnPublishEventHandlerImpl,
+  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+});
+
+//# sourceMappingURL=CancelScheduledActionOnPublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EntryAfterPublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","ScheduledActionTypePublish","createNamespace","CancelScheduledActionOnPublishEventHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","actionType","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnPublishEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnPublishEventHandler.ts"],"sourcesContent":["import { EntryAfterPublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled \"publish\" when an entry is manually published\n *\n * When a user manually publishes an entry, any scheduled publish\n * action for that entry should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnPublishEventHandlerImpl\n    implements EntryAfterPublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterPublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: ScheduledActionTypePublish,\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Even if a schedule runs on an already published action, nothing bad will happen.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnPublishEventHandler =\n    EntryAfterPublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnPublishEventHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,6BAA6B,QAAQ,oEAAoE;AAClH,SACIC,4BAA4B,EAC5BC,2BAA2B,EAC3BC,0BAA0B,QACvB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,8CAA8C,CAEpD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAA0C,EAAiB;IACpE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACR,oBAAoB,CAACS,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACQ,KAAK,CAAC;QACjCO,UAAU,EAAEhB,0BAA0B;QACtCiB,QAAQ,EAAET,KAAK,CAACU;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGP,aAAa,CAACQ,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAAClB,qBAAqB,CAACQ,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,0CAA0C,GACnD5B,6BAA6B,CAAC6B,oBAAoB,CAAC;EAC/CC,cAAc,EAAEzB,8CAA8C;EAC9D0B,YAAY,EAAE,CAAC7B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.d.ts

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

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EntryAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","createNamespace","CancelScheduledActionOnDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnRevisionDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnRevisionDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled actions when an entry revision is deleted\n *\n * When a user deletes an entry revision, any scheduled publish/unpublish\n * action for that revision should be canceled since the revision\n * no longer exists.\n */\nclass CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was deleted successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnRevisionDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnDeleteHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,mEAAmE;AAChH,SACIC,4BAA4B,EAC5BC,2BAA2B,QACxB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACR,oBAAoB,CAACS,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACQ,KAAK,CAAC;QACjCO,QAAQ,EAAER,KAAK,CAACS;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGN,aAAa,CAACO,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAACjB,qBAAqB,CAACQ,OAAO,CAACQ,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,iDAAiD,GAC1D1B,4BAA4B,CAAC2B,oBAAoB,CAAC;EAC9CC,cAAc,EAAExB,wCAAwC;EACxDyB,YAAY,EAAE,CAAC3B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.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;
+    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledAction: CancelScheduledActionUseCase.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,49 @@
+import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
+
+/**
+ * Cancels scheduled action when an entry is manually unpublished
+ *
+ * When a user manually unpublishes an entry revision, any scheduled unpublish
+ * action for that revision should be canceled since the manual action
+ * takes precedence.
+ */
+class CancelScheduledActionOnUnpublishHandlerImpl {
+  constructor(listScheduledActions, cancelScheduledAction) {
+    this.listScheduledActions = listScheduledActions;
+    this.cancelScheduledAction = cancelScheduledAction;
+  }
+  async handle(event) {
+    const {
+      entry,
+      model
+    } = event.payload;
+
+    // Skip private models
+    if (model.isPrivate) {
+      return;
+    }
+    const actionsResult = await this.listScheduledActions.execute({
+      where: {
+        namespace: createNamespace(model),
+        actionType: ScheduledActionTypeUnpublish,
+        targetId: entry.id
+      }
+    });
+    const actions = actionsResult.value.items;
+    for (const action of actions) {
+      const cancelRes = await this.cancelScheduledAction.execute(action);
+      if (cancelRes.isFail()) {
+        // Silently ignore errors - this is non-critical cleanup.
+        // Entry was unpublished successfully, cancelling scheduled actions is best-effort.
+      }
+    }
+  }
+}
+export const CancelScheduledActionOnUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
+  implementation: CancelScheduledActionOnUnpublishHandlerImpl,
+  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+});
+
+//# sourceMappingURL=CancelScheduledActionOnUnpublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EntryAfterUnpublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","ScheduledActionTypeUnpublish","createNamespace","CancelScheduledActionOnUnpublishHandlerImpl","constructor","listScheduledActions","cancelScheduledAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","actionType","targetId","id","actions","value","items","action","cancelRes","isFail","CancelScheduledActionOnUnpublishEventHandler","createImplementation","implementation","dependencies"],"sources":["CancelScheduledActionOnUnpublishEventHandler.ts"],"sourcesContent":["import { EntryAfterUnpublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { createNamespace } from \"~/utils/namespace.js\";\n\n/**\n * Cancels scheduled action when an entry is manually unpublished\n *\n * When a user manually unpublishes an entry revision, any scheduled unpublish\n * action for that revision should be canceled since the manual action\n * takes precedence.\n */\nclass CancelScheduledActionOnUnpublishHandlerImpl\n    implements EntryAfterUnpublishEventHandler.Interface\n{\n    constructor(\n        private listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private cancelScheduledAction: CancelScheduledActionUseCase.Interface\n    ) {}\n\n    async handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Skip private models\n        if (model.isPrivate) {\n            return;\n        }\n\n        const actionsResult = await this.listScheduledActions.execute({\n            where: {\n                namespace: createNamespace(model),\n                actionType: ScheduledActionTypeUnpublish,\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledAction.execute(action);\n            if (cancelRes.isFail()) {\n                // Silently ignore errors - this is non-critical cleanup.\n                // Entry was unpublished successfully, cancelling scheduled actions is best-effort.\n            }\n        }\n    }\n}\n\nexport const CancelScheduledActionOnUnpublishEventHandler =\n    EntryAfterUnpublishEventHandler.createImplementation({\n        implementation: CancelScheduledActionOnUnpublishHandlerImpl,\n        dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]\n    });\n"],"mappings":"AAAA,SAASA,+BAA+B,QAAQ,sEAAsE;AACtH,SACIC,4BAA4B,EAC5BC,2BAA2B,EAC3BC,4BAA4B,QACzB,gDAAgD;AACvD,SAASC,eAAe;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,2CAA2C,CAEjD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,qBAA6D,EACvE;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,qBAA6D,GAA7DA,qBAA6D;EACtE;EAEH,MAAMC,MAAMA,CAACC,KAA4C,EAAiB;IACtE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,SAAS,EAAE;MACjB;IACJ;IAEA,MAAMC,aAAa,GAAG,MAAM,IAAI,CAACR,oBAAoB,CAACS,OAAO,CAAC;MAC1DC,KAAK,EAAE;QACHC,SAAS,EAAEd,eAAe,CAACQ,KAAK,CAAC;QACjCO,UAAU,EAAEhB,4BAA4B;QACxCiB,QAAQ,EAAET,KAAK,CAACU;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGP,aAAa,CAACQ,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAAClB,qBAAqB,CAACQ,OAAO,CAACS,MAAM,CAAC;MAClE,IAAIC,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,4CAA4C,GACrD5B,+BAA+B,CAAC6B,oBAAoB,CAAC;EACjDC,cAAc,EAAEzB,2CAA2C;EAC3D0B,YAAY,EAAE,CAAC7B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}

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,24 @@
+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";
+
+/**
+ * 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 const CancelScheduledActionOnEntryChangeFeature = createFeature({
+  name: "CancelScheduledActionOnEntryChange",
+  register(container) {
+    container.register(CancelScheduledActionOnPublishEventHandler);
+    container.register(CancelScheduledActionOnUnpublishEventHandler);
+    container.register(CancelScheduledActionOnEntryDeleteEventHandler);
+    container.register(CancelScheduledActionOnRevisionDeleteEventHandler);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/CancelScheduledActionOnEntryChange/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CancelScheduledActionOnPublishEventHandler","CancelScheduledActionOnUnpublishEventHandler","CancelScheduledActionOnEntryDeleteEventHandler","CancelScheduledActionOnRevisionDeleteEventHandler","CancelScheduledActionOnEntryChangeFeature","name","register","container"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,0CAA0C;AACnD,SAASC,4CAA4C;AACrD,SAASC,8CAA8C;AACvD,SAASC,iDAAiD;;AAE1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,yCAAyC,GAAGL,aAAa,CAAC;EACnEM,IAAI,EAAE,oCAAoC;EAC1CC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACN,0CAA0C,CAAC;IAC9DO,SAAS,CAACD,QAAQ,CAACL,4CAA4C,CAAC;IAChEM,SAAS,CAACD,QAAQ,CAACJ,8CAA8C,CAAC;IAClEK,SAAS,CAACD,QAAQ,CAACH,iDAAiD,CAAC;EACzE;AACJ,CAAC,CAAC","ignoreList":[]}

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,50 @@
+import { NamespaceHandler as NamespaceHandlerAbstraction } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { extractModelIdFromNamespace } from "../../utils/namespace.js";
+import { Result } from "@webiny/feature/exports/api.js";
+import { 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) {
+    /**
+     * 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.
+     */
+    const modelId = extractModelIdFromNamespace(params.namespace);
+    // Fetch the target model
+    const modelResult = await this.getModelUseCase.execute(modelId);
+    if (modelResult.isFail()) {
+      return Result.fail(modelResult.error);
+    }
+    const model = modelResult.value;
+
+    // Fetch entry to get title
+    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
+    });
+  }
+}
+export const NamespaceHandler = NamespaceHandlerAbstraction.createImplementation({
+  implementation: NamespaceHandlerImpl,
+  dependencies: [GetModelUseCase, GetEntryByIdUseCase]
+});
+
+//# sourceMappingURL=NamespaceHandler.js.map

package/features/NamespaceHandler/NamespaceHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NamespaceHandler","NamespaceHandlerAbstraction","extractModelIdFromNamespace","Result","GetModelUseCase","GetEntryByIdUseCase","NamespaceHandlerImpl","constructor","getModelUseCase","getEntryByIdUseCase","canHandle","namespace","modelId","execute","params","modelResult","isFail","fail","error","model","value","entryResult","targetId","entry","title","values","titleFieldId","ok","actionType","scheduleId","immediately","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,gBAAgB,IAAIC,2BAA2B,QAAQ,gDAAgD;AAChH,SAASC,2BAA2B;AACpC,SAASC,MAAM,QAAQ,gCAAgC;AACvD,SAASC,eAAe,QAAQ,kEAAkE;AAClG,SAASC,mBAAmB,QAAQ,sEAAsE;AAG1G,MAAMC,oBAAoB,CAAiE;EAChFC,WAAWA,CACNC,eAA0C,EAC1CC,mBAAkD,EAC5D;IAAA,KAFUD,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,mBAAkD,GAAlDA,mBAAkD;EAC3D;EAEIC,SAASA,CAACC,SAAiB,EAAW;IACzC,MAAMC,OAAO,GAAGV,2BAA2B,CAACS,SAAS,CAAC;IAEtD,OAAO,CAAC,CAACC,OAAO;EACpB;EAEA,MAAaC,OAAOA,CAChBC,MAA0C,EACS;IACnD;AACR;AACA;IACQ,MAAMF,OAAO,GAAGV,2BAA2B,CAACY,MAAM,CAACH,SAAS,CAAE;IAC9D;IACA,MAAMI,WAAW,GAAG,MAAM,IAAI,CAACP,eAAe,CAACK,OAAO,CAACD,OAAO,CAAC;IAC/D,IAAIG,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;MACtB,OAAOb,MAAM,CAACc,IAAI,CAACF,WAAW,CAACG,KAAY,CAAC;IAChD;IAEA,MAAMC,KAAK,GAAGJ,WAAW,CAACK,KAAK;;IAE/B;IACA,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACZ,mBAAmB,CAACI,OAAO,CAACM,KAAK,EAAEL,MAAM,CAACQ,QAAQ,CAAC;IAClF,IAAID,WAAW,CAACL,MAAM,CAAC,CAAC,EAAE;MACtB,OAAOb,MAAM,CAACc,IAAI,CAACI,WAAW,CAACH,KAAY,CAAC;IAChD;IAEA,MAAMK,KAAK,GAAGF,WAAW,CAACD,KAAK;IAC/B,MAAMI,KAAK,GAAGD,KAAK,CAACE,MAAM,CAACN,KAAK,CAACO,YAAY,CAAC,IAAI,qBAAqB;IAEvE,OAAOvB,MAAM,CAACwB,EAAE,CAAC;MACbhB,SAAS,EAAEG,MAAM,CAACH,SAAS;MAC3Ba,KAAK;MACLZ,OAAO;MACPgB,UAAU,EAAEd,MAAM,CAACc,UAAU;MAC7BN,QAAQ,EAAER,MAAM,CAACQ,QAAQ;MACzBO,UAAU,EAAEf,MAAM,CAACe,UAAU;MAC7BC,WAAW,EAAEhB,MAAM,CAACgB,WAAW,IAAI;IACvC,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAM9B,gBAAgB,GAAGC,2BAA2B,CAAC8B,oBAAoB,CAAC;EAC7EC,cAAc,EAAE1B,oBAAoB;EACpC2B,YAAY,EAAE,CAAC7B,eAAe,EAAEC,mBAAmB;AACvD,CAAC,CAAC","ignoreList":[]}