@webiny/api-headless-cms-scheduler 6.0.0-alpha.5 → 6.0.0-rc.1

package/features/CancelScheduledEntryAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CancelScheduledEntryActionUseCase","CancelScheduledEntryActionFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CancelScheduledEntryActionUseCase } from \"./CancelScheduledEntryActionUseCase.js\";\n\n/**\n * CancelScheduledEntryAction Feature\n *\n * Provides the ability to cancel scheduled CMS entry actions (publish/unpublish).\n */\nexport const CancelScheduledEntryActionFeature = createFeature({\n    name: \"CancelScheduledEntryAction\",\n    register(container) {\n        container.register(CancelScheduledEntryActionUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,iCAAiC;;AAE1C;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,iCAAiC,GAAGF,aAAa,CAAC;EAC3DG,IAAI,EAAE,4BAA4B;EAClCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,iCAAiC,CAAC;EACzD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledEntryAction/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/CancelScheduledEntryAction/index.js

@@ -0,0 +1,3 @@
+export * from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/CancelScheduledEntryAction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\n"],"mappings":"AAAA","ignoreList":[]}

package/features/ScheduleEntryAction/ScheduleEntryActionUseCase.d.ts

@@ -0,0 +1,27 @@
+import { Result } from "@webiny/feature/api";
+import { type IScheduleActionPayload, ScheduleEntryActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { IScheduledAction } from "@webiny/api-scheduler";
+import { ScheduleActionUseCase } from "@webiny/api-scheduler";
+import { RunActionUseCase } from "@webiny/api-scheduler";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+/**
+ * Schedules a CMS entry action (publish or unpublish)
+ *
+ * Flow:
+ * 1. If immediately=true, use RunAction for immediate execution
+ * 2. Otherwise, fetch entry to get title metadata
+ * 3. Use ScheduleAction with entry title in payload
+ */
+declare class ScheduleEntryActionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private scheduleActionUseCase;
+    private runActionUseCase;
+    private getModelUseCase;
+    private getEntryByIdUseCase;
+    constructor(scheduleActionUseCase: ScheduleActionUseCase.Interface, runActionUseCase: RunActionUseCase.Interface, getModelUseCase: GetModelUseCase.Interface, getEntryByIdUseCase: GetEntryByIdUseCase.Interface);
+    execute(input: UseCaseAbstraction.Input): Promise<Result<IScheduledAction<IScheduleActionPayload>, UseCaseAbstraction.Error>>;
+}
+export declare const ScheduleEntryActionUseCase: typeof ScheduleEntryActionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IScheduleEntryActionUseCase>;
+};
+export {};

package/features/ScheduleEntryAction/ScheduleEntryActionUseCase.js

@@ -0,0 +1,83 @@
+import { Result } from "@webiny/feature/api";
+import { ScheduleEntryActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduleActionUseCase } from "@webiny/api-scheduler";
+import { RunActionUseCase } from "@webiny/api-scheduler";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+/**
+ * Schedules a CMS entry action (publish or unpublish)
+ *
+ * Flow:
+ * 1. If immediately=true, use RunAction for immediate execution
+ * 2. Otherwise, fetch entry to get title metadata
+ * 3. Use ScheduleAction with entry title in payload
+ */
+class ScheduleEntryActionUseCaseImpl {
+  constructor(scheduleActionUseCase, runActionUseCase, getModelUseCase, getEntryByIdUseCase) {
+    this.scheduleActionUseCase = scheduleActionUseCase;
+    this.runActionUseCase = runActionUseCase;
+    this.getModelUseCase = getModelUseCase;
+    this.getEntryByIdUseCase = getEntryByIdUseCase;
+  }
+  async execute(input) {
+    const namespace = `Cms/Entry/${input.modelId}`;
+
+    // Handle immediate execution
+    if (input.immediately) {
+      const result = await this.runActionUseCase.execute({
+        namespace,
+        actionType: input.actionType,
+        targetId: input.targetId,
+        payload: {
+          modelId: input.modelId
+        }
+      });
+      if (result.isFail()) {
+        return Result.fail(result.error);
+      }
+      return Result.ok(result.value);
+    }
+
+    // Validate scheduleFor is provided for future scheduling
+    if (!input.scheduleFor) {
+      throw new Error("scheduleFor is required when immediately is not true");
+    }
+
+    // Fetch the target model
+    const modelResult = await this.getModelUseCase.execute(input.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, input.targetId);
+    if (entryResult.isFail()) {
+      return Result.fail(entryResult.error);
+    }
+    const entry = entryResult.value;
+    const title = entry.values[model.titleFieldId] || "Unknown entry title";
+
+    // Schedule with title metadata
+    const scheduleResult = await this.scheduleActionUseCase.execute({
+      namespace,
+      actionType: input.actionType,
+      targetId: input.targetId,
+      title,
+      scheduleFor: input.scheduleFor,
+      payload: {
+        modelId: input.modelId
+      }
+    });
+    if (scheduleResult.isFail()) {
+      return Result.fail(scheduleResult.error);
+    }
+    return Result.ok(scheduleResult.value);
+  }
+}
+export const ScheduleEntryActionUseCase = UseCaseAbstraction.createImplementation({
+  implementation: ScheduleEntryActionUseCaseImpl,
+  dependencies: [ScheduleActionUseCase, RunActionUseCase, GetModelUseCase, GetEntryByIdUseCase]
+});
+
+//# sourceMappingURL=ScheduleEntryActionUseCase.js.map

package/features/ScheduleEntryAction/ScheduleEntryActionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ScheduleEntryActionUseCase","UseCaseAbstraction","ScheduleActionUseCase","RunActionUseCase","GetModelUseCase","GetEntryByIdUseCase","ScheduleEntryActionUseCaseImpl","constructor","scheduleActionUseCase","runActionUseCase","getModelUseCase","getEntryByIdUseCase","execute","input","namespace","modelId","immediately","result","actionType","targetId","payload","isFail","fail","error","ok","value","scheduleFor","Error","modelResult","model","entryResult","entry","title","values","titleFieldId","scheduleResult","createImplementation","implementation","dependencies"],"sources":["ScheduleEntryActionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type IScheduleActionPayload,\n    ScheduleEntryActionUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport type { IScheduledAction } from \"@webiny/api-scheduler\";\nimport { ScheduleActionUseCase } from \"@webiny/api-scheduler\";\nimport { RunActionUseCase } from \"@webiny/api-scheduler\";\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 { ModelNotFoundError } from \"@webiny/api-headless-cms/domain/contentModel/errors.js\";\nimport type { EntryNotFoundError } from \"@webiny/api-headless-cms/domain/contentEntry/errors.js\";\n\n/**\n * Schedules a CMS entry action (publish or unpublish)\n *\n * Flow:\n * 1. If immediately=true, use RunAction for immediate execution\n * 2. Otherwise, fetch entry to get title metadata\n * 3. Use ScheduleAction with entry title in payload\n */\nclass ScheduleEntryActionUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private scheduleActionUseCase: ScheduleActionUseCase.Interface,\n        private runActionUseCase: RunActionUseCase.Interface,\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async execute(\n        input: UseCaseAbstraction.Input\n    ): Promise<Result<IScheduledAction<IScheduleActionPayload>, UseCaseAbstraction.Error>> {\n        const namespace = `Cms/Entry/${input.modelId}`;\n\n        // Handle immediate execution\n        if (input.immediately) {\n            const result = await this.runActionUseCase.execute<IScheduleActionPayload>({\n                namespace,\n                actionType: input.actionType,\n                targetId: input.targetId,\n                payload: {\n                    modelId: input.modelId\n                }\n            });\n\n            if (result.isFail()) {\n                return Result.fail(result.error);\n            }\n\n            return Result.ok(result.value);\n        }\n\n        // Validate scheduleFor is provided for future scheduling\n        if (!input.scheduleFor) {\n            throw new Error(\"scheduleFor is required when immediately is not true\");\n        }\n\n        // Fetch the target model\n        const modelResult = await this.getModelUseCase.execute(input.modelId);\n        if (modelResult.isFail()) {\n            return Result.fail(modelResult.error as ModelNotFoundError);\n        }\n\n        const model = modelResult.value;\n\n        // Fetch entry to get title\n        const entryResult = await this.getEntryByIdUseCase.execute(model, input.targetId);\n        if (entryResult.isFail()) {\n            return Result.fail(entryResult.error as EntryNotFoundError);\n        }\n\n        const entry = entryResult.value;\n        const title = entry.values[model.titleFieldId] || \"Unknown entry title\";\n\n        // Schedule with title metadata\n        const scheduleResult = await this.scheduleActionUseCase.execute<IScheduleActionPayload>({\n            namespace,\n            actionType: input.actionType,\n            targetId: input.targetId,\n            title,\n            scheduleFor: input.scheduleFor,\n            payload: {\n                modelId: input.modelId\n            }\n        });\n\n        if (scheduleResult.isFail()) {\n            return Result.fail(scheduleResult.error);\n        }\n\n        return Result.ok(scheduleResult.value);\n    }\n}\n\nexport const ScheduleEntryActionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ScheduleEntryActionUseCaseImpl,\n    dependencies: [ScheduleActionUseCase, RunActionUseCase, GetModelUseCase, GetEntryByIdUseCase]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/ScheduleEntryAction/abstractions.d.ts

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import type { IScheduledAction } from "@webiny/api-scheduler";
+import { InvalidScheduleDateError, ScheduledActionPersistenceError, SchedulerServiceError } from "@webiny/api-scheduler/domain/errors.js";
+import type { ModelNotFoundError } from "@webiny/api-headless-cms/domain/contentModel/errors.js";
+import type { EntryNotFoundError } from "@webiny/api-headless-cms/domain/contentEntry/errors.js";
+/**
+ * ScheduleEntryActionUseCase - Schedule a CMS entry action (publish/unpublish)
+ *
+ * This is a convenience use case for scheduling CMS entry actions.
+ * It handles:
+ * - Immediate execution (via RunAction)
+ * - Future scheduling (via ScheduleAction)
+ * - Fetching entry title for schedule metadata
+ */
+export type ScheduleEntryActionType = "Publish" | "Unpublish";
+export interface IScheduleActionPayload {
+    modelId: string;
+}
+export interface IScheduleActionWithPayload extends IScheduledAction<IScheduleActionPayload> {
+}
+export interface IScheduleEntryActionInput {
+    modelId: string;
+    targetId: string;
+    actionType: ScheduleEntryActionType;
+    immediately?: boolean;
+    scheduleFor?: string;
+}
+export interface IScheduleEntryActionErrors {
+    persistence: ScheduledActionPersistenceError;
+    invalidDate: InvalidScheduleDateError;
+    schedulerService: SchedulerServiceError;
+    modelNotFound: ModelNotFoundError;
+    entryNotFound: EntryNotFoundError;
+}
+type ScheduleEntryActionError = IScheduleEntryActionErrors[keyof IScheduleEntryActionErrors];
+export interface IScheduleEntryActionUseCase {
+    execute(input: IScheduleEntryActionInput): Promise<Result<IScheduledAction<IScheduleActionPayload>, ScheduleEntryActionError>>;
+}
+export declare const ScheduleEntryActionUseCase: import("@webiny/di").Abstraction<IScheduleEntryActionUseCase>;
+export declare namespace ScheduleEntryActionUseCase {
+    type Interface = IScheduleEntryActionUseCase;
+    type Input = IScheduleEntryActionInput;
+    type Error = ScheduleEntryActionError;
+}
+export {};

package/features/ScheduleEntryAction/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ScheduleEntryActionUseCase - Schedule a CMS entry action (publish/unpublish)
+ *
+ * This is a convenience use case for scheduling CMS entry actions.
+ * It handles:
+ * - Immediate execution (via RunAction)
+ * - Future scheduling (via ScheduleAction)
+ * - Fetching entry title for schedule metadata
+ */
+
+export const ScheduleEntryActionUseCase = createAbstraction("ScheduleEntryActionUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/ScheduleEntryAction/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ScheduleEntryActionUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { IScheduledAction } from \"@webiny/api-scheduler\";\nimport {\n    InvalidScheduleDateError,\n    ScheduledActionPersistenceError,\n    SchedulerServiceError\n} from \"@webiny/api-scheduler/domain/errors.js\";\nimport type { ModelNotFoundError } from \"@webiny/api-headless-cms/domain/contentModel/errors.js\";\nimport type { EntryNotFoundError } from \"@webiny/api-headless-cms/domain/contentEntry/errors.js\";\n\n/**\n * ScheduleEntryActionUseCase - Schedule a CMS entry action (publish/unpublish)\n *\n * This is a convenience use case for scheduling CMS entry actions.\n * It handles:\n * - Immediate execution (via RunAction)\n * - Future scheduling (via ScheduleAction)\n * - Fetching entry title for schedule metadata\n */\n\nexport type ScheduleEntryActionType = \"Publish\" | \"Unpublish\";\n\nexport interface IScheduleActionPayload {\n    modelId: string;\n}\n\nexport interface IScheduleActionWithPayload extends IScheduledAction<IScheduleActionPayload> {}\n\nexport interface IScheduleEntryActionInput {\n    modelId: string;\n    targetId: string;\n    actionType: ScheduleEntryActionType;\n    immediately?: boolean;\n    scheduleFor?: string;\n}\n\nexport interface IScheduleEntryActionErrors {\n    persistence: ScheduledActionPersistenceError;\n    invalidDate: InvalidScheduleDateError;\n    schedulerService: SchedulerServiceError;\n    modelNotFound: ModelNotFoundError;\n    entryNotFound: EntryNotFoundError;\n}\n\ntype ScheduleEntryActionError = IScheduleEntryActionErrors[keyof IScheduleEntryActionErrors];\n\nexport interface IScheduleEntryActionUseCase {\n    execute(\n        input: IScheduleEntryActionInput\n    ): Promise<Result<IScheduledAction<IScheduleActionPayload>, ScheduleEntryActionError>>;\n}\n\nexport const ScheduleEntryActionUseCase = createAbstraction<IScheduleEntryActionUseCase>(\n    \"ScheduleEntryActionUseCase\"\n);\n\nexport namespace ScheduleEntryActionUseCase {\n    export type Interface = IScheduleEntryActionUseCase;\n    export type Input = IScheduleEntryActionInput;\n    export type Error = ScheduleEntryActionError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAU/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkCA,OAAO,MAAMC,0BAA0B,GAAGD,iBAAiB,CACvD,4BACJ,CAAC","ignoreList":[]}

package/features/ScheduleEntryAction/actionHandlers/PublishEntryActionHandler.d.ts

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

package/features/ScheduleEntryAction/actionHandlers/PublishEntryActionHandler.js

@@ -0,0 +1,109 @@
+import { ScheduledActionHandler } from "@webiny/api-scheduler";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetPublishedEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds";
+import { PublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry";
+import { UnpublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry";
+import { RepublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/RepublishEntry";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+
+/**
+ * Handler for publishing CMS entries
+ *
+ * Handles the "Publish" action for CMS entries with namespace pattern: Cms/Entry/{modelId}
+ *
+ * Publishing logic:
+ * 1. If entry is not published -> publish it
+ * 2. If the same revision is already published -> republish it
+ * 3. If a different revision is published -> unpublish old, publish new
+ */
+class PublishEntryActionHandlerImpl {
+  constructor(getModelUseCase, getEntryByIdUseCase, getPublishedEntriesByIdsUseCase, publishEntryUseCase, unpublishEntryUseCase, republishEntryUseCase, identityContext) {
+    this.getModelUseCase = getModelUseCase;
+    this.getEntryByIdUseCase = getEntryByIdUseCase;
+    this.getPublishedEntriesByIdsUseCase = getPublishedEntriesByIdsUseCase;
+    this.publishEntryUseCase = publishEntryUseCase;
+    this.unpublishEntryUseCase = unpublishEntryUseCase;
+    this.republishEntryUseCase = republishEntryUseCase;
+    this.identityContext = identityContext;
+  }
+  canHandle(namespace, actionType) {
+    return namespace.startsWith("Cms/Entry/") && actionType === "Publish";
+  }
+  async handle(action) {
+    const {
+      payload
+    } = action;
+    const modelId = payload.modelId;
+
+    // Fetch the model
+    const modelResult = await this.getModelUseCase.execute(modelId);
+    if (modelResult.isFail()) {
+      console.error(`Failed to get model "${modelId}" for scheduled publish action:`, modelResult.error, {
+        identity: this.identityContext.getIdentity()
+      });
+      throw new Error(`Model not found: ${modelId}`);
+    }
+    const model = modelResult.value;
+
+    // Fetch the target entry
+    const targetEntryResult = await this.getEntryByIdUseCase.execute(model, action.targetId);
+    if (targetEntryResult.isFail()) {
+      console.error(`Failed to get entry "${action.targetId}" for scheduled publish action:`, targetEntryResult.error);
+      throw new Error(`Entry not found: ${action.targetId}`);
+    }
+    const targetEntry = targetEntryResult.value;
+
+    // Get published entries
+    const publishedEntriesResult = await this.getPublishedEntriesByIdsUseCase.execute(model, [targetEntry.id]);
+    if (publishedEntriesResult.isFail()) {
+      console.error(`Failed to get published entries for "${targetEntry.id}":`, publishedEntriesResult.error);
+      throw new Error(`Failed to check published entries`);
+    }
+    const [publishedTargetEntry] = publishedEntriesResult.value;
+
+    /**
+     * Scenario 1: Entry has no published revision -> publish it
+     */
+    if (!publishedTargetEntry) {
+      const publishResult = await this.publishEntryUseCase.execute(model, targetEntry.id);
+      if (publishResult.isFail()) {
+        console.error(`Failed to publish entry "${action.targetId}":`, publishResult.error);
+        throw new Error(`Failed to publish entry: ${action.targetId}`);
+      }
+      return;
+    }
+
+    /**
+     * Scenario 2: Target entry is already published (same revision) -> republish it
+     */
+    if (publishedTargetEntry.id === targetEntry.id) {
+      const republishResult = await this.republishEntryUseCase.execute(model, targetEntry.id);
+      if (republishResult.isFail()) {
+        console.error(`Failed to republish entry "${action.targetId}":`, republishResult.error);
+        throw new Error(`Failed to republish entry: ${action.targetId}`);
+      }
+      return;
+    }
+
+    /**
+     * Scenario 3: A different revision is published -> unpublish old, publish new
+     */
+    const unpublishResult = await this.unpublishEntryUseCase.execute(model, publishedTargetEntry.id);
+    if (unpublishResult.isFail()) {
+      console.error(`Failed to unpublish old revision "${publishedTargetEntry.id}":`, unpublishResult.error);
+      throw new Error(`Failed to unpublish old revision: ${publishedTargetEntry.id}`);
+    }
+    const publishResult = await this.publishEntryUseCase.execute(model, targetEntry.id);
+    if (publishResult.isFail()) {
+      console.error(`Failed to publish entry "${action.targetId}":`, publishResult.error);
+      throw new Error(`Failed to publish entry: ${action.targetId}`);
+    }
+  }
+}
+export const PublishEntryActionHandler = ScheduledActionHandler.createImplementation({
+  implementation: PublishEntryActionHandlerImpl,
+  dependencies: [GetModelUseCase, GetEntryByIdUseCase, GetPublishedEntriesByIdsUseCase, PublishEntryUseCase, UnpublishEntryUseCase, RepublishEntryUseCase, IdentityContext]
+});
+
+//# sourceMappingURL=PublishEntryActionHandler.js.map

package/features/ScheduleEntryAction/actionHandlers/PublishEntryActionHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ScheduledActionHandler","GetModelUseCase","GetEntryByIdUseCase","GetPublishedEntriesByIdsUseCase","PublishEntryUseCase","UnpublishEntryUseCase","RepublishEntryUseCase","IdentityContext","PublishEntryActionHandlerImpl","constructor","getModelUseCase","getEntryByIdUseCase","getPublishedEntriesByIdsUseCase","publishEntryUseCase","unpublishEntryUseCase","republishEntryUseCase","identityContext","canHandle","namespace","actionType","startsWith","handle","action","payload","modelId","modelResult","execute","isFail","console","error","identity","getIdentity","Error","model","value","targetEntryResult","targetId","targetEntry","publishedEntriesResult","id","publishedTargetEntry","publishResult","republishResult","unpublishResult","PublishEntryActionHandler","createImplementation","implementation","dependencies"],"sources":["PublishEntryActionHandler.ts"],"sourcesContent":["import { ScheduledActionHandler } from \"@webiny/api-scheduler\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { GetPublishedEntriesByIdsUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds\";\nimport { PublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry\";\nimport { UnpublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry\";\nimport { RepublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/RepublishEntry\";\nimport type { IScheduleActionWithPayload } from \"~/features/ScheduleEntryAction/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\n\n/**\n * Handler for publishing CMS entries\n *\n * Handles the \"Publish\" action for CMS entries with namespace pattern: Cms/Entry/{modelId}\n *\n * Publishing logic:\n * 1. If entry is not published -> publish it\n * 2. If the same revision is already published -> republish it\n * 3. If a different revision is published -> unpublish old, publish new\n */\nclass PublishEntryActionHandlerImpl implements ScheduledActionHandler.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface,\n        private getPublishedEntriesByIdsUseCase: GetPublishedEntriesByIdsUseCase.Interface,\n        private publishEntryUseCase: PublishEntryUseCase.Interface,\n        private unpublishEntryUseCase: UnpublishEntryUseCase.Interface,\n        private republishEntryUseCase: RepublishEntryUseCase.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    public canHandle(namespace: string, actionType: string): boolean {\n        return namespace.startsWith(\"Cms/Entry/\") && actionType === \"Publish\";\n    }\n\n    public async handle(action: IScheduleActionWithPayload): Promise<void> {\n        const { payload } = action;\n\n        const modelId = payload.modelId as string;\n\n        // Fetch the model\n        const modelResult = await this.getModelUseCase.execute(modelId);\n        if (modelResult.isFail()) {\n            console.error(\n                `Failed to get model \"${modelId}\" for scheduled publish action:`,\n                modelResult.error,\n                {\n                    identity: this.identityContext.getIdentity()\n                }\n            );\n            throw new Error(`Model not found: ${modelId}`);\n        }\n\n        const model = modelResult.value;\n\n        // Fetch the target entry\n        const targetEntryResult =\n            await this.getEntryByIdUseCase.execute<IScheduleActionWithPayload>(\n                model,\n                action.targetId\n            );\n        if (targetEntryResult.isFail()) {\n            console.error(\n                `Failed to get entry \"${action.targetId}\" for scheduled publish action:`,\n                targetEntryResult.error\n            );\n            throw new Error(`Entry not found: ${action.targetId}`);\n        }\n\n        const targetEntry = targetEntryResult.value;\n\n        // Get published entries\n        const publishedEntriesResult =\n            await this.getPublishedEntriesByIdsUseCase.execute<IScheduleActionWithPayload>(model, [\n                targetEntry.id\n            ]);\n\n        if (publishedEntriesResult.isFail()) {\n            console.error(\n                `Failed to get published entries for \"${targetEntry.id}\":`,\n                publishedEntriesResult.error\n            );\n            throw new Error(`Failed to check published entries`);\n        }\n\n        const [publishedTargetEntry] = publishedEntriesResult.value;\n\n        /**\n         * Scenario 1: Entry has no published revision -> publish it\n         */\n        if (!publishedTargetEntry) {\n            const publishResult =\n                await this.publishEntryUseCase.execute<IScheduleActionWithPayload>(\n                    model,\n                    targetEntry.id\n                );\n            if (publishResult.isFail()) {\n                console.error(`Failed to publish entry \"${action.targetId}\":`, publishResult.error);\n                throw new Error(`Failed to publish entry: ${action.targetId}`);\n            }\n            return;\n        }\n\n        /**\n         * Scenario 2: Target entry is already published (same revision) -> republish it\n         */\n        if (publishedTargetEntry.id === targetEntry.id) {\n            const republishResult = await this.republishEntryUseCase.execute(model, targetEntry.id);\n            if (republishResult.isFail()) {\n                console.error(\n                    `Failed to republish entry \"${action.targetId}\":`,\n                    republishResult.error\n                );\n                throw new Error(`Failed to republish entry: ${action.targetId}`);\n            }\n            return;\n        }\n\n        /**\n         * Scenario 3: A different revision is published -> unpublish old, publish new\n         */\n        const unpublishResult =\n            await this.unpublishEntryUseCase.execute<IScheduleActionWithPayload>(\n                model,\n                publishedTargetEntry.id\n            );\n        if (unpublishResult.isFail()) {\n            console.error(\n                `Failed to unpublish old revision \"${publishedTargetEntry.id}\":`,\n                unpublishResult.error\n            );\n            throw new Error(`Failed to unpublish old revision: ${publishedTargetEntry.id}`);\n        }\n\n        const publishResult = await this.publishEntryUseCase.execute<IScheduleActionWithPayload>(\n            model,\n            targetEntry.id\n        );\n        if (publishResult.isFail()) {\n            console.error(`Failed to publish entry \"${action.targetId}\":`, publishResult.error);\n            throw new Error(`Failed to publish entry: ${action.targetId}`);\n        }\n    }\n}\n\nexport const PublishEntryActionHandler = ScheduledActionHandler.createImplementation({\n    implementation: PublishEntryActionHandlerImpl,\n    dependencies: [\n        GetModelUseCase,\n        GetEntryByIdUseCase,\n        GetPublishedEntriesByIdsUseCase,\n        PublishEntryUseCase,\n        UnpublishEntryUseCase,\n        RepublishEntryUseCase,\n        IdentityContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/ScheduleEntryAction/actionHandlers/UnpublishEntryActionHandler.d.ts

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

package/features/ScheduleEntryAction/actionHandlers/UnpublishEntryActionHandler.js

@@ -0,0 +1,92 @@
+import { ScheduledActionHandler } from "@webiny/api-scheduler";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetPublishedEntriesByIdsUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds";
+import { UnpublishEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry";
+/**
+ * Handler for unpublishing CMS entries
+ *
+ * Handles the "Unpublish" action for CMS entries with namespace pattern: Cms/Entry/{modelId}
+ *
+ * Unpublishing logic:
+ * 1. If entry is not published -> nothing to do (warn)
+ * 2. If target entry is published (same revision) -> unpublish it
+ * 3. If a different revision is published -> unpublish it anyway
+ */
+class UnpublishEntryActionHandlerImpl {
+  constructor(getModelUseCase, getEntryByIdUseCase, getPublishedEntriesByIdsUseCase, unpublishEntryUseCase) {
+    this.getModelUseCase = getModelUseCase;
+    this.getEntryByIdUseCase = getEntryByIdUseCase;
+    this.getPublishedEntriesByIdsUseCase = getPublishedEntriesByIdsUseCase;
+    this.unpublishEntryUseCase = unpublishEntryUseCase;
+  }
+  canHandle(namespace, actionType) {
+    return namespace.startsWith("Cms/Entry/") && actionType === "Unpublish";
+  }
+  async handle(action) {
+    const {
+      payload
+    } = action;
+    const modelId = payload.modelId;
+
+    // Fetch the model
+    const modelResult = await this.getModelUseCase.execute(modelId);
+    if (modelResult.isFail()) {
+      console.error(`Failed to get model "${modelId}" for scheduled unpublish action:`, modelResult.error);
+      throw new Error(`Model not found: ${modelId}`);
+    }
+    const model = modelResult.value;
+
+    // Fetch the target entry
+    const targetEntryResult = await this.getEntryByIdUseCase.execute(model, action.targetId);
+    if (targetEntryResult.isFail()) {
+      console.error(`Failed to get entry "${action.targetId}" for scheduled unpublish action:`, targetEntryResult.error);
+      throw new Error(`Entry not found: ${action.targetId}`);
+    }
+    const targetEntry = targetEntryResult.value;
+
+    // Get published entries
+    const publishedEntriesResult = await this.getPublishedEntriesByIdsUseCase.execute(model, [targetEntry.id]);
+    if (publishedEntriesResult.isFail()) {
+      console.error(`Failed to get published entries for "${targetEntry.id}":`, publishedEntriesResult.error);
+      throw new Error(`Failed to check published entries`);
+    }
+    const [publishedTargetEntry] = publishedEntriesResult.value;
+
+    /**
+     * Scenario 1: Entry is not published -> nothing to do
+     */
+    if (!publishedTargetEntry) {
+      console.warn(`Entry "${action.targetId}" is not published, nothing to unpublish.`);
+      return;
+    }
+
+    /**
+     * Scenario 2: Target entry is published (same revision) -> unpublish it
+     */
+    if (publishedTargetEntry.id === action.targetId) {
+      const unpublishResult = await this.unpublishEntryUseCase.execute(model, action.targetId);
+      if (unpublishResult.isFail()) {
+        console.error(`Failed to unpublish entry "${action.targetId}":`, unpublishResult.error);
+        throw new Error(`Failed to unpublish entry: ${action.targetId}`);
+      }
+      return;
+    }
+
+    /**
+     * Scenario 3: A different revision is published -> unpublish it anyway
+     * TODO: Determine if we really want to unpublish an entry which does not match the target ID
+     */
+    const unpublishResult = await this.unpublishEntryUseCase.execute(model, publishedTargetEntry.id);
+    if (unpublishResult.isFail()) {
+      console.error(`Failed to unpublish published revision "${publishedTargetEntry.id}":`, unpublishResult.error);
+      throw new Error(`Failed to unpublish entry: ${publishedTargetEntry.id}`);
+    }
+  }
+}
+export const UnpublishEntryActionHandler = ScheduledActionHandler.createImplementation({
+  implementation: UnpublishEntryActionHandlerImpl,
+  dependencies: [GetModelUseCase, GetEntryByIdUseCase, GetPublishedEntriesByIdsUseCase, UnpublishEntryUseCase]
+});
+
+//# sourceMappingURL=UnpublishEntryActionHandler.js.map

package/features/ScheduleEntryAction/actionHandlers/UnpublishEntryActionHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ScheduledActionHandler","GetModelUseCase","GetEntryByIdUseCase","GetPublishedEntriesByIdsUseCase","UnpublishEntryUseCase","UnpublishEntryActionHandlerImpl","constructor","getModelUseCase","getEntryByIdUseCase","getPublishedEntriesByIdsUseCase","unpublishEntryUseCase","canHandle","namespace","actionType","startsWith","handle","action","payload","modelId","modelResult","execute","isFail","console","error","Error","model","value","targetEntryResult","targetId","targetEntry","publishedEntriesResult","id","publishedTargetEntry","warn","unpublishResult","UnpublishEntryActionHandler","createImplementation","implementation","dependencies"],"sources":["UnpublishEntryActionHandler.ts"],"sourcesContent":["import { ScheduledActionHandler } from \"@webiny/api-scheduler\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { GetPublishedEntriesByIdsUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetPublishedEntriesByIds\";\nimport { UnpublishEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry\";\nimport type { IScheduleActionWithPayload } from \"~/features/ScheduleEntryAction/index.js\";\n\n/**\n * Handler for unpublishing CMS entries\n *\n * Handles the \"Unpublish\" action for CMS entries with namespace pattern: Cms/Entry/{modelId}\n *\n * Unpublishing logic:\n * 1. If entry is not published -> nothing to do (warn)\n * 2. If target entry is published (same revision) -> unpublish it\n * 3. If a different revision is published -> unpublish it anyway\n */\nclass UnpublishEntryActionHandlerImpl implements ScheduledActionHandler.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface,\n        private getPublishedEntriesByIdsUseCase: GetPublishedEntriesByIdsUseCase.Interface,\n        private unpublishEntryUseCase: UnpublishEntryUseCase.Interface\n    ) {}\n\n    canHandle(namespace: string, actionType: string): boolean {\n        return namespace.startsWith(\"Cms/Entry/\") && actionType === \"Unpublish\";\n    }\n\n    async handle(action: IScheduleActionWithPayload): Promise<void> {\n        const { payload } = action;\n\n        const modelId = payload.modelId as string;\n\n        // Fetch the model\n        const modelResult = await this.getModelUseCase.execute(modelId);\n        if (modelResult.isFail()) {\n            console.error(\n                `Failed to get model \"${modelId}\" for scheduled unpublish action:`,\n                modelResult.error\n            );\n            throw new Error(`Model not found: ${modelId}`);\n        }\n\n        const model = modelResult.value;\n\n        // Fetch the target entry\n        const targetEntryResult =\n            await this.getEntryByIdUseCase.execute<IScheduleActionWithPayload>(\n                model,\n                action.targetId\n            );\n        if (targetEntryResult.isFail()) {\n            console.error(\n                `Failed to get entry \"${action.targetId}\" for scheduled unpublish action:`,\n                targetEntryResult.error\n            );\n            throw new Error(`Entry not found: ${action.targetId}`);\n        }\n\n        const targetEntry = targetEntryResult.value;\n\n        // Get published entries\n        const publishedEntriesResult =\n            await this.getPublishedEntriesByIdsUseCase.execute<IScheduleActionWithPayload>(model, [\n                targetEntry.id\n            ]);\n\n        if (publishedEntriesResult.isFail()) {\n            console.error(\n                `Failed to get published entries for \"${targetEntry.id}\":`,\n                publishedEntriesResult.error\n            );\n            throw new Error(`Failed to check published entries`);\n        }\n\n        const [publishedTargetEntry] = publishedEntriesResult.value;\n\n        /**\n         * Scenario 1: Entry is not published -> nothing to do\n         */\n        if (!publishedTargetEntry) {\n            console.warn(`Entry \"${action.targetId}\" is not published, nothing to unpublish.`);\n            return;\n        }\n\n        /**\n         * Scenario 2: Target entry is published (same revision) -> unpublish it\n         */\n        if (publishedTargetEntry.id === action.targetId) {\n            const unpublishResult =\n                await this.unpublishEntryUseCase.execute<IScheduleActionWithPayload>(\n                    model,\n                    action.targetId\n                );\n            if (unpublishResult.isFail()) {\n                console.error(\n                    `Failed to unpublish entry \"${action.targetId}\":`,\n                    unpublishResult.error\n                );\n                throw new Error(`Failed to unpublish entry: ${action.targetId}`);\n            }\n            return;\n        }\n\n        /**\n         * Scenario 3: A different revision is published -> unpublish it anyway\n         * TODO: Determine if we really want to unpublish an entry which does not match the target ID\n         */\n        const unpublishResult =\n            await this.unpublishEntryUseCase.execute<IScheduleActionWithPayload>(\n                model,\n                publishedTargetEntry.id\n            );\n        if (unpublishResult.isFail()) {\n            console.error(\n                `Failed to unpublish published revision \"${publishedTargetEntry.id}\":`,\n                unpublishResult.error\n            );\n            throw new Error(`Failed to unpublish entry: ${publishedTargetEntry.id}`);\n        }\n    }\n}\n\nexport const UnpublishEntryActionHandler = ScheduledActionHandler.createImplementation({\n    implementation: UnpublishEntryActionHandlerImpl,\n    dependencies: [\n        GetModelUseCase,\n        GetEntryByIdUseCase,\n        GetPublishedEntriesByIdsUseCase,\n        UnpublishEntryUseCase\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/ScheduleEntryAction/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ScheduleEntryAction Feature
+ *
+ * Provides the ability to schedule CMS entry actions (publish/unpublish).
+ * Handles both immediate execution and future scheduling.
+ */
+export declare const ScheduleEntryActionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/ScheduleEntryAction/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/api";
+import { ScheduleEntryActionUseCase } from "./ScheduleEntryActionUseCase.js";
+import { PublishEntryActionHandler } from "./actionHandlers/PublishEntryActionHandler.js";
+import { UnpublishEntryActionHandler } from "./actionHandlers/UnpublishEntryActionHandler.js";
+
+/**
+ * ScheduleEntryAction Feature
+ *
+ * Provides the ability to schedule CMS entry actions (publish/unpublish).
+ * Handles both immediate execution and future scheduling.
+ */
+export const ScheduleEntryActionFeature = createFeature({
+  name: "ScheduleEntryAction",
+  register(container) {
+    container.register(ScheduleEntryActionUseCase);
+    container.register(PublishEntryActionHandler);
+    container.register(UnpublishEntryActionHandler);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/ScheduleEntryAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ScheduleEntryActionUseCase","PublishEntryActionHandler","UnpublishEntryActionHandler","ScheduleEntryActionFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ScheduleEntryActionUseCase } from \"./ScheduleEntryActionUseCase.js\";\nimport { PublishEntryActionHandler } from \"./actionHandlers/PublishEntryActionHandler.js\";\nimport { UnpublishEntryActionHandler } from \"./actionHandlers/UnpublishEntryActionHandler.js\";\n\n/**\n * ScheduleEntryAction Feature\n *\n * Provides the ability to schedule CMS entry actions (publish/unpublish).\n * Handles both immediate execution and future scheduling.\n */\nexport const ScheduleEntryActionFeature = createFeature({\n    name: \"ScheduleEntryAction\",\n    register(container) {\n        container.register(ScheduleEntryActionUseCase);\n        container.register(PublishEntryActionHandler);\n        container.register(UnpublishEntryActionHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,0BAA0B;AACnC,SAASC,yBAAyB;AAClC,SAASC,2BAA2B;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,0BAA0B,GAAGJ,aAAa,CAAC;EACpDK,IAAI,EAAE,qBAAqB;EAC3BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,0BAA0B,CAAC;IAC9CM,SAAS,CAACD,QAAQ,CAACJ,yBAAyB,CAAC;IAC7CK,SAAS,CAACD,QAAQ,CAACH,2BAA2B,CAAC;EACnD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/ScheduleEntryAction/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/ScheduleEntryAction/index.js

@@ -0,0 +1,3 @@
+export * from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/ScheduleEntryAction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\n"],"mappings":"AAAA","ignoreList":[]}

package/graphql/ActionMapper.d.ts

@@ -0,0 +1,15 @@
+import type { IScheduleActionWithPayload } from "../features/ScheduleEntryAction/index.js";
+export declare class ActionMapper {
+    static fromScheduledAction(action: IScheduleActionWithPayload): {
+        id: string;
+        targetId: string;
+        model: {
+            modelId: string;
+        };
+        scheduledBy: import("@webiny/api-scheduler/shared/abstractions").Identity;
+        publishOn: string | null;
+        unpublishOn: string | null;
+        type: string;
+        title: string | undefined;
+    };
+}

package/graphql/ActionMapper.js

@@ -0,0 +1,18 @@
+export class ActionMapper {
+  static fromScheduledAction(action) {
+    return {
+      id: action.id,
+      targetId: action.targetId,
+      model: {
+        modelId: action.payload?.modelId
+      },
+      scheduledBy: action.scheduledBy,
+      publishOn: action.actionType === "Publish" ? action.scheduledFor : null,
+      unpublishOn: action.actionType === "Unpublish" ? action.scheduledFor : null,
+      type: action.actionType.toLowerCase(),
+      title: action.title
+    };
+  }
+}
+
+//# sourceMappingURL=ActionMapper.js.map

package/graphql/ActionMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ActionMapper","fromScheduledAction","action","id","targetId","model","modelId","payload","scheduledBy","publishOn","actionType","scheduledFor","unpublishOn","type","toLowerCase","title"],"sources":["ActionMapper.ts"],"sourcesContent":["import type { IScheduleActionWithPayload } from \"~/features/ScheduleEntryAction/index.js\";\n\nexport class ActionMapper {\n    static fromScheduledAction(action: IScheduleActionWithPayload) {\n        return {\n            id: action.id,\n            targetId: action.targetId,\n            model: {\n                modelId: action.payload?.modelId\n            },\n            scheduledBy: action.scheduledBy,\n            publishOn: action.actionType === \"Publish\" ? action.scheduledFor : null,\n            unpublishOn: action.actionType === \"Unpublish\" ? action.scheduledFor : null,\n            type: action.actionType.toLowerCase(),\n            title: action.title\n        };\n    }\n}\n"],"mappings":"AAEA,OAAO,MAAMA,YAAY,CAAC;EACtB,OAAOC,mBAAmBA,CAACC,MAAkC,EAAE;IAC3D,OAAO;MACHC,EAAE,EAAED,MAAM,CAACC,EAAE;MACbC,QAAQ,EAAEF,MAAM,CAACE,QAAQ;MACzBC,KAAK,EAAE;QACHC,OAAO,EAAEJ,MAAM,CAACK,OAAO,EAAED;MAC7B,CAAC;MACDE,WAAW,EAAEN,MAAM,CAACM,WAAW;MAC/BC,SAAS,EAAEP,MAAM,CAACQ,UAAU,KAAK,SAAS,GAAGR,MAAM,CAACS,YAAY,GAAG,IAAI;MACvEC,WAAW,EAAEV,MAAM,CAACQ,UAAU,KAAK,WAAW,GAAGR,MAAM,CAACS,YAAY,GAAG,IAAI;MAC3EE,IAAI,EAAEX,MAAM,CAACQ,UAAU,CAACI,WAAW,CAAC,CAAC;MACrCC,KAAK,EAAEb,MAAM,CAACa;IAClB,CAAC;EACL;AACJ","ignoreList":[]}