@webiny/api-headless-cms-scheduler 0.0.0-unstable.6844005670 → 0.0.0-unstable.7be00a75a9

package/context.js

@@ -1,13 +1,18 @@
 import { ContextPlugin } from "@webiny/api";
-import { ScheduleEntryActionFeature } from "./features/ScheduleEntryAction/feature.js";
-import { CancelScheduledEntryActionFeature } from "./features/CancelScheduledEntryAction/feature.js";
 import { CancelScheduledActionOnEntryChangeFeature } from "./features/CancelScheduledActionOnEntryChange/feature.js";
-export const createHeadlessCmsScheduleContext = () => {
-  return new ContextPlugin(async context => {
-    ScheduleEntryActionFeature.register(context.container);
-    CancelScheduledEntryActionFeature.register(context.container);
-    CancelScheduledActionOnEntryChangeFeature.register(context.container);
-  });
-};
+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 createHeadlessCmsScheduleContext = ()=>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);
+    });
+export { createHeadlessCmsScheduleContext };
 
 //# sourceMappingURL=context.js.map

package/context.js.map

@@ -1 +1 @@
-{"version":3,"names":["ContextPlugin","ScheduleEntryActionFeature","CancelScheduledEntryActionFeature","CancelScheduledActionOnEntryChangeFeature","createHeadlessCmsScheduleContext","context","register","container"],"sources":["context.ts"],"sourcesContent":["import { ContextPlugin } from \"@webiny/api\";\nimport { ScheduleEntryActionFeature } from \"~/features/ScheduleEntryAction/feature.js\";\nimport { CancelScheduledEntryActionFeature } from \"~/features/CancelScheduledEntryAction/feature.js\";\nimport { CancelScheduledActionOnEntryChangeFeature } from \"~/features/CancelScheduledActionOnEntryChange/feature.js\";\n\nexport const createHeadlessCmsScheduleContext = () => {\n    return new ContextPlugin(async context => {\n        ScheduleEntryActionFeature.register(context.container);\n        CancelScheduledEntryActionFeature.register(context.container);\n        CancelScheduledActionOnEntryChangeFeature.register(context.container);\n    });\n};\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,aAAa;AAC3C,SAASC,0BAA0B;AACnC,SAASC,iCAAiC;AAC1C,SAASC,yCAAyC;AAElD,OAAO,MAAMC,gCAAgC,GAAGA,CAAA,KAAM;EAClD,OAAO,IAAIJ,aAAa,CAAC,MAAMK,OAAO,IAAI;IACtCJ,0BAA0B,CAACK,QAAQ,CAACD,OAAO,CAACE,SAAS,CAAC;IACtDL,iCAAiC,CAACI,QAAQ,CAACD,OAAO,CAACE,SAAS,CAAC;IAC7DJ,yCAAyC,CAACG,QAAQ,CAACD,OAAO,CAACE,SAAS,CAAC;EACzE,CAAC,CAAC;AACN,CAAC","ignoreList":[]}
+{"version":3,"file":"context.js","sources":["../src/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"],"names":["createHeadlessCmsScheduleContext","ContextPlugin","context","NamespaceHandler","PublishEntryActionHandler","UnpublishEntryActionHandler","SchedulePublishEntryUseCase","ScheduleUnpublishEntryUseCase","CancelScheduledActionOnEntryChangeFeature"],"mappings":";;;;;;;AAQO,MAAMA,mCAAmC,IACrC,IAAIC,cAAc,OAAMC;QAC3BA,QAAQ,SAAS,CAAC,QAAQ,CAACC;QAC3BD,QAAQ,SAAS,CAAC,QAAQ,CAACE;QAC3BF,QAAQ,SAAS,CAAC,QAAQ,CAACG;QAC3BH,QAAQ,SAAS,CAAC,QAAQ,CAACI;QAC3BJ,QAAQ,SAAS,CAAC,QAAQ,CAACK;QAE3BC,0CAA0C,QAAQ,CAACN,QAAQ,SAAS;IACxE"}

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

@@ -1,5 +1,5 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
-import { ListScheduledActionsUseCase, CancelScheduledActionUseCase } from "@webiny/api-scheduler";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
 /**
  * Cancels scheduled actions when an entry is deleted
  *
@@ -9,12 +9,12 @@ import { ListScheduledActionsUseCase, CancelScheduledActionUseCase } from "@webi
  */
 declare class CancelScheduledActionOnEntryDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
     private listScheduledActions;
-    private cancelScheduledEntryAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface);
+    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>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js

@@ -1,51 +1,40 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
-import { ListScheduledActionsUseCase, CancelScheduledActionUseCase } from "@webiny/api-scheduler";
-
-/**
- * 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.
- */
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
 class CancelScheduledActionOnEntryDeleteHandlerImpl {
-  constructor(listScheduledActions, cancelScheduledEntryAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledEntryAction = cancelScheduledEntryAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const schedules = await this.listSchedules(model.modelId, entry.entryId);
+        for (const action of schedules){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-    const schedules = await this.listSchedules(model.modelId, entry.entryId);
-    for (const action of schedules) {
-      const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
-      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;
     }
-  }
-  async listSchedules(modelId, entryId) {
-    const actionsResult = await this.listScheduledActions.execute({
-      limit: 10000,
-      where: {
-        namespace: `Cms/Entry/${modelId}`,
-        targetId_startsWith: `${entryId}#`
-      }
-    });
-    return actionsResult.value.items;
-  }
 }
-export const CancelScheduledActionOnEntryDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnEntryDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnEntryDeleteHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
 });
+export { CancelScheduledActionOnEntryDeleteEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnEntryDeleteEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase","CancelScheduledActionOnEntryDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledEntryAction","handle","event","entry","model","payload","isPrivate","schedules","listSchedules","modelId","entryId","action","cancelRes","execute","id","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 { ListScheduledActionsUseCase, CancelScheduledActionUseCase } from \"@webiny/api-scheduler\";\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 cancelScheduledEntryAction: 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.cancelScheduledEntryAction.execute(action.id);\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: `Cms/Entry/${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,SAASC,2BAA2B,EAAEC,4BAA4B,QAAQ,uBAAuB;;AAEjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,6CAA6C,CAEnD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,0BAAkE,EAC5E;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,0BAAkE,GAAlEA,0BAAkE;EAC3E;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,0BAA0B,CAACa,OAAO,CAACF,MAAM,CAACG,EAAE,CAAC;MAC1E,IAAIF,SAAS,CAACG,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;EAEA,MAAcP,aAAaA,CAACC,OAAe,EAAEC,OAAe,EAAE;IAC1D,MAAMM,aAAa,GAAG,MAAM,IAAI,CAACjB,oBAAoB,CAACc,OAAO,CAAC;MAC1DI,KAAK,EAAE,KAAK;MACZC,KAAK,EAAE;QACHC,SAAS,EAAE,aAAaV,OAAO,EAAE;QACjCW,mBAAmB,EAAE,GAAGV,OAAO;MACnC;IACJ,CAAC,CAAC;IAEF,OAAOM,aAAa,CAACK,KAAK,CAACC,KAAK;EACpC;AACJ;AAEA,OAAO,MAAMC,8CAA8C,GACvD7B,4BAA4B,CAAC8B,oBAAoB,CAAC;EAC9CC,cAAc,EAAE5B,6CAA6C;EAC7D6B,YAAY,EAAE,CAAC/B,2BAA2B,EAAEC,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnEntryDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { 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"],"names":["CancelScheduledActionOnEntryDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","event","entry","model","schedules","action","cancelRes","modelId","entryId","actionsResult","createNamespace","CancelScheduledActionOnEntryDeleteEventHandler","EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;AAcA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;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,OAAOC,cAAc,KAAK,CAAC,KAAK;IACpC;AACJ;AAEO,MAAME,iDACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBd;IAChB,cAAc;QAACe;QAA6BC;KAA6B;AAC7E"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.d.ts

@@ -1,5 +1,5 @@
 import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
 /**
  * Cancels scheduled "publish" when an entry is manually published
  *
@@ -9,11 +9,11 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
  */
 declare class CancelScheduledActionOnPublishEventHandlerImpl implements EntryAfterPublishEventHandler.Interface {
     private listScheduledActions;
-    private cancelScheduledEntryAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface);
+    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>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/PublishEntry/events").EntryAfterPublishEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js

@@ -1,48 +1,35 @@
 import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
-
-/**
- * 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.
- */
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypePublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
 class CancelScheduledActionOnPublishEventHandlerImpl {
-  constructor(listScheduledActions, cancelScheduledEntryAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledEntryAction = cancelScheduledEntryAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
     }
-    const actionsResult = await this.listScheduledActions.execute({
-      where: {
-        namespace: `Cms/Entry/${model.modelId}`,
-        actionType: "Publish",
-        targetId: entry.id
-      }
-    });
-    const actions = actionsResult.value.items;
-    for (const action of actions) {
-      const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
-      if (cancelRes.isFail()) {
-        // Silently ignore errors - this is non-critical cleanup.
-        // Even if a schedule runs on an already published action, nothing bad will happen.
-      }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                actionType: ScheduledActionTypePublish,
+                targetId: entry.id
+            }
+        });
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-  }
 }
-export const CancelScheduledActionOnPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnPublishEventHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnPublishEventHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
 });
+export { CancelScheduledActionOnPublishEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnPublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterPublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","CancelScheduledActionOnPublishEventHandlerImpl","constructor","listScheduledActions","cancelScheduledEntryAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","modelId","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 { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from \"@webiny/api-scheduler\";\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 cancelScheduledEntryAction: 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: `Cms/Entry/${model.modelId}`,\n                actionType: \"Publish\",\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);\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,SAASC,4BAA4B,EAAEC,2BAA2B,QAAQ,uBAAuB;;AAEjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,8CAA8C,CAEpD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,0BAAkE,EAC5E;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,0BAAkE,GAAlEA,0BAAkE;EAC3E;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,EAAE,aAAaN,KAAK,CAACO,OAAO,EAAE;QACvCC,UAAU,EAAE,SAAS;QACrBC,QAAQ,EAAEV,KAAK,CAACW;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGR,aAAa,CAACS,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAACnB,0BAA0B,CAACQ,OAAO,CAACU,MAAM,CAACJ,EAAE,CAAC;MAC1E,IAAIK,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,0CAA0C,GACnD3B,6BAA6B,CAAC4B,oBAAoB,CAAC;EAC/CC,cAAc,EAAE1B,8CAA8C;EAC9D2B,YAAY,EAAE,CAAC5B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnPublishEventHandler.ts"],"sourcesContent":["import { EntryAfterPublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypePublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { 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"],"names":["CancelScheduledActionOnPublishEventHandlerImpl","listScheduledActions","cancelScheduledAction","event","entry","model","actionsResult","createNamespace","ScheduledActionTypePublish","actions","action","cancelRes","CancelScheduledActionOnPublishEventHandler","EntryAfterPublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;AAeA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;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,MAAMK,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,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;KAA6B;AAC7E"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.d.ts

@@ -1,5 +1,5 @@
 import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
 /**
  * Cancels scheduled actions when an entry revision is deleted
  *
@@ -9,11 +9,11 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
  */
 declare class CancelScheduledActionOnDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
     private listScheduledActions;
-    private cancelScheduledEntryAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface);
+    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>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events").EntryAfterDeleteEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js

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

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterDeleteEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","CancelScheduledActionOnDeleteHandlerImpl","constructor","listScheduledActions","cancelScheduledEntryAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","modelId","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 { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from \"@webiny/api-scheduler\";\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 cancelScheduledEntryAction: 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: `Cms/Entry/${model.modelId}`,\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.cancelScheduledEntryAction.execute(action.id);\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,SAASC,4BAA4B,EAAEC,2BAA2B,QAAQ,uBAAuB;;AAEjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CACCC,oBAA2D,EAC3DC,0BAAkE,EAC5E;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,0BAAkE,GAAlEA,0BAAkE;EAC3E;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,EAAE,aAAaN,KAAK,CAACO,OAAO,EAAE;QACvCC,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,0BAA0B,CAACQ,OAAO,CAACS,MAAM,CAACJ,EAAE,CAAC;MAC1E,IAAIK,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,iDAAiD,GAC1D1B,4BAA4B,CAAC2B,oBAAoB,CAAC;EAC9CC,cAAc,EAAEzB,wCAAwC;EACxD0B,YAAY,EAAE,CAAC3B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnRevisionDeleteEventHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { 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"],"names":["CancelScheduledActionOnDeleteHandlerImpl","listScheduledActions","cancelScheduledAction","event","entry","model","actionsResult","createNamespace","actions","action","cancelRes","CancelScheduledActionOnRevisionDeleteEventHandler","EntryAfterDeleteEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;AAcA,MAAMA;IACF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;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,MAAMI,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,gBAAgBZ;IAChB,cAAc;QAACa;QAA6BC;KAA6B;AAC7E"}

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.d.ts

@@ -1,5 +1,5 @@
 import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler/exports/api/scheduler.js";
 /**
  * Cancels scheduled action when an entry is manually unpublished
  *
@@ -9,11 +9,11 @@ import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webi
  */
 declare class CancelScheduledActionOnUnpublishHandlerImpl implements EntryAfterUnpublishEventHandler.Interface {
     private listScheduledActions;
-    private cancelScheduledEntryAction;
-    constructor(listScheduledActions: ListScheduledActionsUseCase.Interface, cancelScheduledEntryAction: CancelScheduledActionUseCase.Interface);
+    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>>;
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events").EntryAfterUnpublishEvent>>;
 };
 export {};

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js

@@ -1,48 +1,35 @@
 import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events";
-import { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from "@webiny/api-scheduler";
-
-/**
- * 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.
- */
+import { CancelScheduledActionUseCase, ListScheduledActionsUseCase, ScheduledActionTypeUnpublish } from "@webiny/api-scheduler/exports/api/scheduler.js";
+import { createNamespace } from "../../utils/namespace.js";
 class CancelScheduledActionOnUnpublishHandlerImpl {
-  constructor(listScheduledActions, cancelScheduledEntryAction) {
-    this.listScheduledActions = listScheduledActions;
-    this.cancelScheduledEntryAction = cancelScheduledEntryAction;
-  }
-  async handle(event) {
-    const {
-      entry,
-      model
-    } = event.payload;
-
-    // Skip private models
-    if (model.isPrivate) {
-      return;
+    constructor(listScheduledActions, cancelScheduledAction){
+        this.listScheduledActions = listScheduledActions;
+        this.cancelScheduledAction = cancelScheduledAction;
     }
-    const actionsResult = await this.listScheduledActions.execute({
-      where: {
-        namespace: `Cms/Entry/${model.modelId}`,
-        actionType: "Unpublish",
-        targetId: entry.id
-      }
-    });
-    const actions = actionsResult.value.items;
-    for (const action of actions) {
-      const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);
-      if (cancelRes.isFail()) {
-        // Silently ignore errors - this is non-critical cleanup.
-        // Entry was unpublished successfully, cancelling scheduled actions is best-effort.
-      }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        if (model.isPrivate) return;
+        const actionsResult = await this.listScheduledActions.execute({
+            where: {
+                namespace: createNamespace(model),
+                actionType: ScheduledActionTypeUnpublish,
+                targetId: entry.id
+            }
+        });
+        const actions = actionsResult.value.items;
+        for (const action of actions){
+            const cancelRes = await this.cancelScheduledAction.execute(action);
+            cancelRes.isFail();
+        }
     }
-  }
 }
-export const CancelScheduledActionOnUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
-  implementation: CancelScheduledActionOnUnpublishHandlerImpl,
-  dependencies: [ListScheduledActionsUseCase, CancelScheduledActionUseCase]
+const CancelScheduledActionOnUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
+    implementation: CancelScheduledActionOnUnpublishHandlerImpl,
+    dependencies: [
+        ListScheduledActionsUseCase,
+        CancelScheduledActionUseCase
+    ]
 });
+export { CancelScheduledActionOnUnpublishEventHandler };
 
 //# sourceMappingURL=CancelScheduledActionOnUnpublishEventHandler.js.map

package/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js.map

@@ -1 +1 @@
-{"version":3,"names":["EntryAfterUnpublishEventHandler","CancelScheduledActionUseCase","ListScheduledActionsUseCase","CancelScheduledActionOnUnpublishHandlerImpl","constructor","listScheduledActions","cancelScheduledEntryAction","handle","event","entry","model","payload","isPrivate","actionsResult","execute","where","namespace","modelId","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 { CancelScheduledActionUseCase, ListScheduledActionsUseCase } from \"@webiny/api-scheduler\";\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 cancelScheduledEntryAction: 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: `Cms/Entry/${model.modelId}`,\n                actionType: \"Unpublish\",\n                targetId: entry.id\n            }\n        });\n\n        const actions = actionsResult.value.items;\n\n        for (const action of actions) {\n            const cancelRes = await this.cancelScheduledEntryAction.execute(action.id);\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,SAASC,4BAA4B,EAAEC,2BAA2B,QAAQ,uBAAuB;;AAEjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,2CAA2C,CAEjD;EACIC,WAAWA,CACCC,oBAA2D,EAC3DC,0BAAkE,EAC5E;IAAA,KAFUD,oBAA2D,GAA3DA,oBAA2D;IAAA,KAC3DC,0BAAkE,GAAlEA,0BAAkE;EAC3E;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,EAAE,aAAaN,KAAK,CAACO,OAAO,EAAE;QACvCC,UAAU,EAAE,WAAW;QACvBC,QAAQ,EAAEV,KAAK,CAACW;MACpB;IACJ,CAAC,CAAC;IAEF,MAAMC,OAAO,GAAGR,aAAa,CAACS,KAAK,CAACC,KAAK;IAEzC,KAAK,MAAMC,MAAM,IAAIH,OAAO,EAAE;MAC1B,MAAMI,SAAS,GAAG,MAAM,IAAI,CAACnB,0BAA0B,CAACQ,OAAO,CAACU,MAAM,CAACJ,EAAE,CAAC;MAC1E,IAAIK,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;QACpB;QACA;MAAA;IAER;EACJ;AACJ;AAEA,OAAO,MAAMC,4CAA4C,GACrD3B,+BAA+B,CAAC4B,oBAAoB,CAAC;EACjDC,cAAc,EAAE1B,2CAA2C;EAC3D2B,YAAY,EAAE,CAAC5B,2BAA2B,EAAED,4BAA4B;AAC5E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.js","sources":["../../../src/features/CancelScheduledActionOnEntryChange/CancelScheduledActionOnUnpublishEventHandler.ts"],"sourcesContent":["import { EntryAfterUnpublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/events\";\nimport {\n    CancelScheduledActionUseCase,\n    ListScheduledActionsUseCase,\n    ScheduledActionTypeUnpublish\n} from \"@webiny/api-scheduler/exports/api/scheduler.js\";\nimport { 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"],"names":["CancelScheduledActionOnUnpublishHandlerImpl","listScheduledActions","cancelScheduledAction","event","entry","model","actionsResult","createNamespace","ScheduledActionTypeUnpublish","actions","action","cancelRes","CancelScheduledActionOnUnpublishEventHandler","EntryAfterUnpublishEventHandler","ListScheduledActionsUseCase","CancelScheduledActionUseCase"],"mappings":";;;AAeA,MAAMA;IAGF,YACYC,oBAA2D,EAC3DC,qBAA6D,CACvE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,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,MAAMK,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,gBAAgBb;IAChB,cAAc;QAACc;QAA6BC;KAA6B;AAC7E"}

package/features/CancelScheduledActionOnEntryChange/feature.d.ts

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

package/features/CancelScheduledActionOnEntryChange/feature.js

@@ -3,22 +3,15 @@ import { CancelScheduledActionOnPublishEventHandler } from "./CancelScheduledAct
 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);
-  }
+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