@webiny/api-scheduler 0.0.0-unstable.61c048f412

package/features/ListScheduledActions/ListScheduledActionsUseCase.js

@@ -0,0 +1,77 @@
+import { Result } from "@webiny/feature/api";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+import { ListScheduledActionsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduledActionModel } from "../../shared/abstractions.js";
+import { ScheduledActionPersistenceError } from "../../domain/errors.js";
+import { CmsSortMapper, CmsWhereMapper } from "@webiny/api-headless-cms";
+/**
+ * Lists scheduled actions with optional filtering
+ *
+ * Flow:
+ * 1. Build query filters based on where params (namespace, actionType, targetId, etc.)
+ * 2. Fetch entries from CMS storage with pagination and sorting
+ * 3. Transform CMS entries to IScheduledAction format
+ * 4. Return paginated results with metadata
+ */
+class ListScheduledActionsUseCaseImpl {
+  constructor(listEntriesUseCase, model, cmsWhereMapper, cmsSortMapper) {
+    this.listEntriesUseCase = listEntriesUseCase;
+    this.model = model;
+    this.cmsWhereMapper = cmsWhereMapper;
+    this.cmsSortMapper = cmsSortMapper;
+  }
+  async execute(params) {
+    const {
+      where,
+      sort: sortInput,
+      limit,
+      after
+    } = params;
+    const sort = this.cmsSortMapper.map({
+      input: sortInput,
+      fields: this.model.fields
+    });
+    // List entries from CMS
+    const listResult = await this.listEntriesUseCase.execute(this.model, {
+      where: this.cmsWhereMapper.map({
+        input: where,
+        fields: this.model.fields
+      }),
+      sort,
+      limit,
+      after
+    });
+    if (listResult.isFail()) {
+      return Result.fail(new ScheduledActionPersistenceError(listResult.error));
+    }
+    const {
+      entries,
+      meta
+    } = listResult.value;
+
+    // Transform entries to IScheduledAction format
+    const scheduledActions = entries.map(entry => {
+      return {
+        id: entry.entryId,
+        title: entry.values.title,
+        namespace: entry.values.namespace,
+        actionType: entry.values.actionType,
+        targetId: entry.values.targetId,
+        scheduledBy: entry.values.scheduledBy,
+        scheduledFor: entry.values.scheduledFor,
+        payload: entry.values.payload,
+        error: entry.values.error
+      };
+    });
+    return Result.ok({
+      items: scheduledActions,
+      meta
+    });
+  }
+}
+export const ListScheduledActionsUseCase = UseCaseAbstraction.createImplementation({
+  implementation: ListScheduledActionsUseCaseImpl,
+  dependencies: [ListLatestEntriesUseCase, ScheduledActionModel, CmsWhereMapper, CmsSortMapper]
+});
+
+//# sourceMappingURL=ListScheduledActionsUseCase.js.map

package/features/ListScheduledActions/ListScheduledActionsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListLatestEntriesUseCase","ListScheduledActionsUseCase","UseCaseAbstraction","ScheduledActionModel","ScheduledActionPersistenceError","CmsSortMapper","CmsWhereMapper","ListScheduledActionsUseCaseImpl","constructor","listEntriesUseCase","model","cmsWhereMapper","cmsSortMapper","execute","params","where","sort","sortInput","limit","after","map","input","fields","listResult","isFail","fail","error","entries","meta","value","scheduledActions","entry","id","entryId","title","values","namespace","actionType","targetId","scheduledBy","scheduledFor","payload","ok","items","createImplementation","implementation","dependencies"],"sources":["ListScheduledActionsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js\";\nimport {\n    IListScheduledActionsParams,\n    IListScheduledActionsResponse,\n    ListScheduledActionsUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport type { IScheduledAction } from \"~/shared/abstractions.js\";\nimport { ScheduledActionModel } from \"~/shared/abstractions.js\";\nimport { ScheduledActionPersistenceError } from \"~/domain/errors.js\";\nimport { CmsSortMapper, CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * Lists scheduled actions with optional filtering\n *\n * Flow:\n * 1. Build query filters based on where params (namespace, actionType, targetId, etc.)\n * 2. Fetch entries from CMS storage with pagination and sorting\n * 3. Transform CMS entries to IScheduledAction format\n * 4. Return paginated results with metadata\n */\nclass ListScheduledActionsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private listEntriesUseCase: ListLatestEntriesUseCase.Interface,\n        private model: ScheduledActionModel.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface,\n        private cmsSortMapper: CmsSortMapper.Interface\n    ) {}\n\n    async execute<T extends GenericRecord>(\n        params: IListScheduledActionsParams\n    ): Promise<Result<IListScheduledActionsResponse<T>, UseCaseAbstraction.Error>> {\n        const { where, sort: sortInput, limit, after } = params;\n\n        const sort = this.cmsSortMapper.map({\n            input: sortInput,\n            fields: this.model.fields\n        });\n        // List entries from CMS\n        const listResult = await this.listEntriesUseCase.execute<IScheduledAction<T>>(this.model, {\n            where: this.cmsWhereMapper.map({\n                input: where,\n                fields: this.model.fields\n            }),\n            sort,\n            limit,\n            after\n        });\n\n        if (listResult.isFail()) {\n            return Result.fail(new ScheduledActionPersistenceError(listResult.error));\n        }\n\n        const { entries, meta } = listResult.value;\n\n        // Transform entries to IScheduledAction format\n        const scheduledActions: IScheduledAction<T>[] = entries.map(entry => {\n            return {\n                id: entry.entryId,\n                title: entry.values.title,\n                namespace: entry.values.namespace,\n                actionType: entry.values.actionType,\n                targetId: entry.values.targetId,\n                scheduledBy: entry.values.scheduledBy,\n                scheduledFor: entry.values.scheduledFor,\n                payload: entry.values.payload,\n                error: entry.values.error\n            };\n        });\n\n        return Result.ok({\n            items: scheduledActions,\n            meta\n        });\n    }\n}\n\nexport const ListScheduledActionsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListScheduledActionsUseCaseImpl,\n    dependencies: [ListLatestEntriesUseCase, ScheduledActionModel, CmsWhereMapper, CmsSortMapper]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,wBAAwB,QAAQ,4EAA4E;AACrH,SAGIC,2BAA2B,IAAIC,kBAAkB;AAGrD,SAASC,oBAAoB;AAC7B,SAASC,+BAA+B;AACxC,SAASC,aAAa,EAAEC,cAAc,QAAQ,0BAA0B;AAGxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,+BAA+B,CAAyC;EAC1EC,WAAWA,CACCC,kBAAsD,EACtDC,KAAqC,EACrCC,cAAwC,EACxCC,aAAsC,EAChD;IAAA,KAJUH,kBAAsD,GAAtDA,kBAAsD;IAAA,KACtDC,KAAqC,GAArCA,KAAqC;IAAA,KACrCC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CACTC,MAAmC,EACwC;IAC3E,MAAM;MAAEC,KAAK;MAAEC,IAAI,EAAEC,SAAS;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGL,MAAM;IAEvD,MAAME,IAAI,GAAG,IAAI,CAACJ,aAAa,CAACQ,GAAG,CAAC;MAChCC,KAAK,EAAEJ,SAAS;MAChBK,MAAM,EAAE,IAAI,CAACZ,KAAK,CAACY;IACvB,CAAC,CAAC;IACF;IACA,MAAMC,UAAU,GAAG,MAAM,IAAI,CAACd,kBAAkB,CAACI,OAAO,CAAsB,IAAI,CAACH,KAAK,EAAE;MACtFK,KAAK,EAAE,IAAI,CAACJ,cAAc,CAACS,GAAG,CAAC;QAC3BC,KAAK,EAAEN,KAAK;QACZO,MAAM,EAAE,IAAI,CAACZ,KAAK,CAACY;MACvB,CAAC,CAAC;MACFN,IAAI;MACJE,KAAK;MACLC;IACJ,CAAC,CAAC;IAEF,IAAII,UAAU,CAACC,MAAM,CAAC,CAAC,EAAE;MACrB,OAAOzB,MAAM,CAAC0B,IAAI,CAAC,IAAIrB,+BAA+B,CAACmB,UAAU,CAACG,KAAK,CAAC,CAAC;IAC7E;IAEA,MAAM;MAAEC,OAAO;MAAEC;IAAK,CAAC,GAAGL,UAAU,CAACM,KAAK;;IAE1C;IACA,MAAMC,gBAAuC,GAAGH,OAAO,CAACP,GAAG,CAACW,KAAK,IAAI;MACjE,OAAO;QACHC,EAAE,EAAED,KAAK,CAACE,OAAO;QACjBC,KAAK,EAAEH,KAAK,CAACI,MAAM,CAACD,KAAK;QACzBE,SAAS,EAAEL,KAAK,CAACI,MAAM,CAACC,SAAS;QACjCC,UAAU,EAAEN,KAAK,CAACI,MAAM,CAACE,UAAU;QACnCC,QAAQ,EAAEP,KAAK,CAACI,MAAM,CAACG,QAAQ;QAC/BC,WAAW,EAAER,KAAK,CAACI,MAAM,CAACI,WAAW;QACrCC,YAAY,EAAET,KAAK,CAACI,MAAM,CAACK,YAAY;QACvCC,OAAO,EAAEV,KAAK,CAACI,MAAM,CAACM,OAAO;QAC7Bf,KAAK,EAAEK,KAAK,CAACI,MAAM,CAACT;MACxB,CAAC;IACL,CAAC,CAAC;IAEF,OAAO3B,MAAM,CAAC2C,EAAE,CAAC;MACbC,KAAK,EAAEb,gBAAgB;MACvBF;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAM3B,2BAA2B,GAAGC,kBAAkB,CAAC0C,oBAAoB,CAAC;EAC/EC,cAAc,EAAEtC,+BAA+B;EAC/CuC,YAAY,EAAE,CAAC9C,wBAAwB,EAAEG,oBAAoB,EAAEG,cAAc,EAAED,aAAa;AAChG,CAAC,CAAC","ignoreList":[]}

package/features/ListScheduledActions/abstractions.d.ts

@@ -0,0 +1,49 @@
+import { Result } from "@webiny/feature/api";
+import type { IScheduledAction } from "../../shared/abstractions.js";
+import { ScheduledActionPersistenceError } from "../../domain/errors.js";
+import type { CmsEntryListSort, CmsEntryMeta } from "@webiny/api-headless-cms/types/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * ListScheduledActionsUseCase - List scheduled actions with optional filtering
+ *
+ * Used to retrieve all scheduled actions for a namespace (e.g., all actions for Article model)
+ * or all actions of a specific type across namespaces.
+ *
+ * This is critical for CMS CRUD views where we need to show ALL scheduled actions
+ * (publish, unpublish, delete) for a specific content model.
+ */
+export type DateISOString = `${number}-${number}-${number}T${number}:${number}:${number}.${number}Z`;
+export interface IListScheduledActionsWhere {
+    namespace?: string;
+    namespace_startsWith?: string;
+    actionType?: string;
+    targetId?: string;
+    targetId_startsWith?: string;
+    scheduledBy?: string;
+    scheduledFor?: DateISOString;
+    scheduledFor_gte?: DateISOString;
+    scheduledFor_lte?: DateISOString;
+}
+export interface IListScheduledActionsParams {
+    where: IListScheduledActionsWhere;
+    sort?: CmsEntryListSort;
+    limit?: number;
+    after?: string;
+}
+export interface IListScheduledActionsResponse<T extends GenericRecord> {
+    items: IScheduledAction<T>[];
+    meta: CmsEntryMeta;
+}
+export interface IListScheduledActionsErrors {
+    persistence: ScheduledActionPersistenceError;
+}
+type ListScheduledActionsError = IListScheduledActionsErrors[keyof IListScheduledActionsErrors];
+export interface IListScheduledActionsUseCase {
+    execute<T extends GenericRecord>(params: IListScheduledActionsParams): Promise<Result<IListScheduledActionsResponse<T>, ListScheduledActionsError>>;
+}
+export declare const ListScheduledActionsUseCase: import("@webiny/di").Abstraction<IListScheduledActionsUseCase>;
+export declare namespace ListScheduledActionsUseCase {
+    type Interface = IListScheduledActionsUseCase;
+    type Error = ListScheduledActionsError;
+}
+export {};

package/features/ListScheduledActions/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ListScheduledActionsUseCase - List scheduled actions with optional filtering
+ *
+ * Used to retrieve all scheduled actions for a namespace (e.g., all actions for Article model)
+ * or all actions of a specific type across namespaces.
+ *
+ * This is critical for CMS CRUD views where we need to show ALL scheduled actions
+ * (publish, unpublish, delete) for a specific content model.
+ */
+
+export const ListScheduledActionsUseCase = createAbstraction("ListScheduledActionsUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/ListScheduledActions/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListScheduledActionsUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { IScheduledAction } from \"~/shared/abstractions.js\";\nimport { ScheduledActionPersistenceError } from \"~/domain/errors.js\";\nimport type { CmsEntryListSort, CmsEntryMeta } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * ListScheduledActionsUseCase - List scheduled actions with optional filtering\n *\n * Used to retrieve all scheduled actions for a namespace (e.g., all actions for Article model)\n * or all actions of a specific type across namespaces.\n *\n * This is critical for CMS CRUD views where we need to show ALL scheduled actions\n * (publish, unpublish, delete) for a specific content model.\n */\n\nexport type DateISOString =\n    `${number}-${number}-${number}T${number}:${number}:${number}.${number}Z`;\n\nexport interface IListScheduledActionsWhere {\n    namespace?: string;\n    namespace_startsWith?: string;\n    actionType?: string;\n    targetId?: string;\n    targetId_startsWith?: string;\n    scheduledBy?: string;\n    scheduledFor?: DateISOString;\n    scheduledFor_gte?: DateISOString;\n    scheduledFor_lte?: DateISOString;\n}\n\nexport interface IListScheduledActionsParams {\n    where: IListScheduledActionsWhere;\n    sort?: CmsEntryListSort;\n    limit?: number;\n    after?: string;\n}\n\nexport interface IListScheduledActionsResponse<T extends GenericRecord> {\n    items: IScheduledAction<T>[];\n    meta: CmsEntryMeta;\n}\n\nexport interface IListScheduledActionsErrors {\n    persistence: ScheduledActionPersistenceError;\n}\n\ntype ListScheduledActionsError = IListScheduledActionsErrors[keyof IListScheduledActionsErrors];\n\nexport interface IListScheduledActionsUseCase {\n    execute<T extends GenericRecord>(\n        params: IListScheduledActionsParams\n    ): Promise<Result<IListScheduledActionsResponse<T>, ListScheduledActionsError>>;\n}\n\nexport const ListScheduledActionsUseCase = createAbstraction<IListScheduledActionsUseCase>(\n    \"ListScheduledActionsUseCase\"\n);\n\nexport namespace ListScheduledActionsUseCase {\n    export type Interface = IListScheduledActionsUseCase;\n    export type Error = ListScheduledActionsError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAOvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAyCA,OAAO,MAAMC,2BAA2B,GAAGD,iBAAiB,CACxD,6BACJ,CAAC","ignoreList":[]}

package/features/ListScheduledActions/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ListScheduledActions Feature
+ *
+ * Provides the ability to list scheduled actions with optional filtering by namespace or actionType.
+ * Critical for CMS CRUD views showing all scheduled actions for a content model.
+ */
+export declare const ListScheduledActionsFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/ListScheduledActions/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListScheduledActionsUseCase } from "./ListScheduledActionsUseCase.js";
+
+/**
+ * ListScheduledActions Feature
+ *
+ * Provides the ability to list scheduled actions with optional filtering by namespace or actionType.
+ * Critical for CMS CRUD views showing all scheduled actions for a content model.
+ */
+export const ListScheduledActionsFeature = createFeature({
+  name: "ListScheduledActions",
+  register(container) {
+    container.register(ListScheduledActionsUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/ListScheduledActions/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ListScheduledActionsUseCase","ListScheduledActionsFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListScheduledActionsUseCase } from \"./ListScheduledActionsUseCase.js\";\n\n/**\n * ListScheduledActions Feature\n *\n * Provides the ability to list scheduled actions with optional filtering by namespace or actionType.\n * Critical for CMS CRUD views showing all scheduled actions for a content model.\n */\nexport const ListScheduledActionsFeature = createFeature({\n    name: \"ListScheduledActions\",\n    register(container) {\n        container.register(ListScheduledActionsUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,2BAA2B;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,2BAA2B,GAAGF,aAAa,CAAC;EACrDG,IAAI,EAAE,sBAAsB;EAC5BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,2BAA2B,CAAC;EACnD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/ListScheduledActions/index.d.ts

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

package/features/ListScheduledActions/index.js

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

package/features/ListScheduledActions/index.js.map

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

package/features/RunAction/RunActionUseCase.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "@webiny/feature/api";
+import { RunActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduleActionUseCase } from "../../features/ScheduleAction/abstractions.js";
+import type { IScheduledAction } from "../../shared/abstractions.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * Schedules an action for immediate execution
+ *
+ * Flow:
+ * 1. Calculate the closest possible execution time
+ * 2. Delegate to ScheduleAction use case with calculated time
+ *
+ * Note: We add a small buffer to ensure EventBridge has time to process the schedule
+ */
+declare class RunActionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private scheduleActionUseCase;
+    constructor(scheduleActionUseCase: ScheduleActionUseCase.Interface);
+    execute<T extends GenericRecord>(params: UseCaseAbstraction.Params<T>): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>>;
+}
+export declare const RunActionUseCase: typeof RunActionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRunActionUseCase>;
+};
+export {};

package/features/RunAction/RunActionUseCase.js

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { RunActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduleActionUseCase } from "../ScheduleAction/abstractions.js";
+/**
+ * Schedules an action for immediate execution
+ *
+ * Flow:
+ * 1. Calculate the closest possible execution time
+ * 2. Delegate to ScheduleAction use case with calculated time
+ *
+ * Note: We add a small buffer to ensure EventBridge has time to process the schedule
+ */
+class RunActionUseCaseImpl {
+  constructor(scheduleActionUseCase) {
+    this.scheduleActionUseCase = scheduleActionUseCase;
+  }
+  async execute(params) {
+    // Delegate to ScheduleAction
+    const result = await this.scheduleActionUseCase.execute({
+      ...params,
+      title: "Unknown title",
+      // Calculate the soonest possible execution time.
+      // Add at least 90 seconds of buffer to ensure EventBridge can process the schedule.
+      scheduleFor: new Date(Date.now() + 90000).toISOString()
+    });
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    return Result.ok(result.value);
+  }
+}
+export const RunActionUseCase = UseCaseAbstraction.createImplementation({
+  implementation: RunActionUseCaseImpl,
+  dependencies: [ScheduleActionUseCase]
+});
+
+//# sourceMappingURL=RunActionUseCase.js.map

package/features/RunAction/RunActionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","RunActionUseCase","UseCaseAbstraction","ScheduleActionUseCase","RunActionUseCaseImpl","constructor","scheduleActionUseCase","execute","params","result","title","scheduleFor","Date","now","toISOString","isFail","fail","error","ok","value","createImplementation","implementation","dependencies"],"sources":["RunActionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { RunActionUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { ScheduleActionUseCase } from \"~/features/ScheduleAction/abstractions.js\";\nimport type { IScheduledAction } from \"~/shared/abstractions.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * Schedules an action for immediate execution\n *\n * Flow:\n * 1. Calculate the closest possible execution time\n * 2. Delegate to ScheduleAction use case with calculated time\n *\n * Note: We add a small buffer to ensure EventBridge has time to process the schedule\n */\nclass RunActionUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private scheduleActionUseCase: ScheduleActionUseCase.Interface) {}\n\n    async execute<T extends GenericRecord>(\n        params: UseCaseAbstraction.Params<T>\n    ): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>> {\n        // Delegate to ScheduleAction\n        const result = await this.scheduleActionUseCase.execute({\n            ...params,\n            title: \"Unknown title\",\n            // Calculate the soonest possible execution time.\n            // Add at least 90 seconds of buffer to ensure EventBridge can process the schedule.\n            scheduleFor: new Date(Date.now() + 90000).toISOString()\n        });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const RunActionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: RunActionUseCaseImpl,\n    dependencies: [ScheduleActionUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,gBAAgB,IAAIC,kBAAkB;AAC/C,SAASC,qBAAqB;AAI9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,oBAAoB,CAAyC;EAC/DC,WAAWA,CAASC,qBAAsD,EAAE;IAAA,KAAxDA,qBAAsD,GAAtDA,qBAAsD;EAAG;EAE7E,MAAMC,OAAOA,CACTC,MAAoC,EAC0B;IAC9D;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,qBAAqB,CAACC,OAAO,CAAC;MACpD,GAAGC,MAAM;MACTE,KAAK,EAAE,eAAe;MACtB;MACA;MACAC,WAAW,EAAE,IAAIC,IAAI,CAACA,IAAI,CAACC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAACC,WAAW,CAAC;IAC1D,CAAC,CAAC;IAEF,IAAIL,MAAM,CAACM,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOf,MAAM,CAACgB,IAAI,CAACP,MAAM,CAACQ,KAAK,CAAC;IACpC;IAEA,OAAOjB,MAAM,CAACkB,EAAE,CAACT,MAAM,CAACU,KAAK,CAAC;EAClC;AACJ;AAEA,OAAO,MAAMlB,gBAAgB,GAAGC,kBAAkB,CAACkB,oBAAoB,CAAC;EACpEC,cAAc,EAAEjB,oBAAoB;EACpCkB,YAAY,EAAE,CAACnB,qBAAqB;AACxC,CAAC,CAAC","ignoreList":[]}

package/features/RunAction/abstractions.d.ts

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import type { IScheduledAction } from "../../shared/abstractions.js";
+import { InvalidScheduleDateError, ScheduledActionPersistenceError, SchedulerServiceError } from "../../domain/errors.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * RunActionUseCase - Schedule an action for immediate execution
+ *
+ * This is a convenience use case that wraps ScheduleAction and automatically
+ * calculates the closest possible execution time (current time + small buffer).
+ *
+ * Use this when you want to execute an action "immediately" without having to manually
+ * calculate the schedule date.
+ */
+export interface IRunActionErrors {
+    persistence: ScheduledActionPersistenceError;
+    invalidDate: InvalidScheduleDateError;
+    schedulerService: SchedulerServiceError;
+}
+type RunActionError = IRunActionErrors[keyof IRunActionErrors];
+interface IRunActionParams<T extends GenericRecord> {
+    namespace: string;
+    actionType: string;
+    targetId: string;
+    payload: T;
+}
+export interface IRunActionUseCase {
+    execute<T extends GenericRecord>(params: IRunActionParams<T>): Promise<Result<IScheduledAction<T>, RunActionError>>;
+}
+export declare const RunActionUseCase: import("@webiny/di").Abstraction<IRunActionUseCase>;
+export declare namespace RunActionUseCase {
+    type Interface = IRunActionUseCase;
+    type Params<T extends GenericRecord> = IRunActionParams<T>;
+    type Error = RunActionError;
+}
+export {};

package/features/RunAction/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * RunActionUseCase - Schedule an action for immediate execution
+ *
+ * This is a convenience use case that wraps ScheduleAction and automatically
+ * calculates the closest possible execution time (current time + small buffer).
+ *
+ * Use this when you want to execute an action "immediately" without having to manually
+ * calculate the schedule date.
+ */
+
+export const RunActionUseCase = createAbstraction("RunActionUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/RunAction/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","RunActionUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { IScheduledAction } from \"~/shared/abstractions.js\";\nimport {\n    InvalidScheduleDateError,\n    ScheduledActionPersistenceError,\n    SchedulerServiceError\n} from \"~/domain/errors.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * RunActionUseCase - Schedule an action for immediate execution\n *\n * This is a convenience use case that wraps ScheduleAction and automatically\n * calculates the closest possible execution time (current time + small buffer).\n *\n * Use this when you want to execute an action \"immediately\" without having to manually\n * calculate the schedule date.\n */\n\nexport interface IRunActionErrors {\n    persistence: ScheduledActionPersistenceError;\n    invalidDate: InvalidScheduleDateError;\n    schedulerService: SchedulerServiceError;\n}\n\ntype RunActionError = IRunActionErrors[keyof IRunActionErrors];\n\ninterface IRunActionParams<T extends GenericRecord> {\n    namespace: string;\n    actionType: string;\n    targetId: string;\n    payload: T;\n}\n\nexport interface IRunActionUseCase {\n    execute<T extends GenericRecord>(\n        params: IRunActionParams<T>\n    ): Promise<Result<IScheduledAction<T>, RunActionError>>;\n}\n\nexport const RunActionUseCase = createAbstraction<IRunActionUseCase>(\"RunActionUseCase\");\n\nexport namespace RunActionUseCase {\n    export type Interface = IRunActionUseCase;\n    export type Params<T extends GenericRecord> = IRunActionParams<T>;\n    export type Error = RunActionError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAS/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAuBA,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,kBAAkB,CAAC","ignoreList":[]}

package/features/RunAction/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RunAction Feature
+ *
+ * Provides the ability to schedule an action for immediate execution
+ * without having to manually calculate the schedule date.
+ */
+export declare const RunActionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/RunAction/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { RunActionUseCase } from "./RunActionUseCase.js";
+
+/**
+ * RunAction Feature
+ *
+ * Provides the ability to schedule an action for immediate execution
+ * without having to manually calculate the schedule date.
+ */
+export const RunActionFeature = createFeature({
+  name: "RunAction",
+  register(container) {
+    container.register(RunActionUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/RunAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","RunActionUseCase","RunActionFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { RunActionUseCase } from \"./RunActionUseCase.js\";\n\n/**\n * RunAction Feature\n *\n * Provides the ability to schedule an action for immediate execution\n * without having to manually calculate the schedule date.\n */\nexport const RunActionFeature = createFeature({\n    name: \"RunAction\",\n    register(container) {\n        container.register(RunActionUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gBAAgB;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,gBAAgB,GAAGF,aAAa,CAAC;EAC1CG,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,gBAAgB,CAAC;EACxC;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/RunAction/index.d.ts

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

package/features/RunAction/index.js

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

package/features/RunAction/index.js.map

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

package/features/ScheduleAction/ScheduleActionUseCase.d.ts

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { ScheduleActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetScheduledActionUseCase } from "../../features/GetScheduledAction/abstractions.js";
+import type { IScheduledAction } from "../../shared/abstractions.js";
+import { ScheduledActionModel, SchedulerService } from "../../shared/abstractions.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * Schedules an action for future execution
+ *
+ * Flow:
+ * 1. Generate unique schedule ID from namespace+actionType+targetId
+ * 2. Check if schedule already exists (for rescheduling logic)
+ * 3. If exists: UPDATE schedule entry + EventBridge schedule
+ * 4. If new: CREATE schedule entry + EventBridge schedule
+ * 5. Rollback schedule entry if EventBridge fails
+ *
+ * Note: Does NOT handle immediate execution - apps use direct use cases for that
+ */
+declare class ScheduleActionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private model;
+    private schedulerService;
+    private getScheduledAction;
+    private createEntryUseCase;
+    private updateEntryUseCase;
+    private deleteEntryUseCase;
+    constructor(identityContext: IdentityContext.Interface, model: ScheduledActionModel.Interface, schedulerService: SchedulerService.Interface, getScheduledAction: GetScheduledActionUseCase.Interface, createEntryUseCase: CreateEntryUseCase.Interface, updateEntryUseCase: UpdateEntryUseCase.Interface, deleteEntryUseCase: DeleteEntryUseCase.Interface);
+    execute<T extends GenericRecord>(params: UseCaseAbstraction.Params<T>): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>>;
+    /**
+     * Creates a new schedule
+     */
+    private createSchedule;
+    /**
+     * Updates an existing schedule (reschedule)
+     */
+    private reschedule;
+}
+export declare const ScheduleActionUseCase: typeof ScheduleActionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IScheduleActionUseCase>;
+};
+export {};

package/features/ScheduleAction/ScheduleActionUseCase.js

@@ -0,0 +1,164 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { parseIdentifier } from "@webiny/utils";
+import { ScheduleActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetScheduledActionUseCase } from "../GetScheduledAction/abstractions.js";
+import { ScheduledActionModel, SchedulerService } from "../../shared/abstractions.js";
+import { InvalidScheduleDateError, ScheduledActionPersistenceError, SchedulerServiceError } from "../../domain/errors.js";
+import { ScheduledActionId } from "../../domain/ScheduledActionId.js";
+import { ScheduledActionIdWithVersion } from "../../domain/ScheduledActionIdWithVersion.js";
+import { isValidDate } from "../../domain/isValidDate.js";
+/**
+ * Schedules an action for future execution
+ *
+ * Flow:
+ * 1. Generate unique schedule ID from namespace+actionType+targetId
+ * 2. Check if schedule already exists (for rescheduling logic)
+ * 3. If exists: UPDATE schedule entry + EventBridge schedule
+ * 4. If new: CREATE schedule entry + EventBridge schedule
+ * 5. Rollback schedule entry if EventBridge fails
+ *
+ * Note: Does NOT handle immediate execution - apps use direct use cases for that
+ */
+class ScheduleActionUseCaseImpl {
+  constructor(identityContext, model, schedulerService, getScheduledAction, createEntryUseCase, updateEntryUseCase, deleteEntryUseCase) {
+    this.identityContext = identityContext;
+    this.model = model;
+    this.schedulerService = schedulerService;
+    this.getScheduledAction = getScheduledAction;
+    this.createEntryUseCase = createEntryUseCase;
+    this.updateEntryUseCase = updateEntryUseCase;
+    this.deleteEntryUseCase = deleteEntryUseCase;
+  }
+  async execute(params) {
+    const identity = this.identityContext.getIdentity();
+    if (!isValidDate(params.scheduleFor)) {
+      return Result.fail(new InvalidScheduleDateError(params.scheduleFor));
+    }
+
+    // Generate unique schedule ID
+    const actionId = ScheduledActionId.from(params);
+    const scheduleId = ScheduledActionIdWithVersion.from(actionId);
+    const existingResult = await this.getScheduledAction.execute(scheduleId);
+    if (existingResult.isFail()) {
+      const error = existingResult.error;
+
+      // NotFound means the action was not yet scheduled
+      if (error.code === "Scheduler/ScheduledAction/NotFound") {
+        return this.createSchedule(scheduleId, params.title, params.namespace, params.actionType, params.targetId, params.scheduleFor, identity, params.payload);
+      }
+      if (error.code === "Scheduler/ScheduledAction/PersistenceError") {
+        return Result.fail(error);
+      }
+    }
+
+    // Reschedule existing action
+    const scheduledAction = existingResult.value;
+    return this.reschedule(scheduledAction, params.scheduleFor, identity, params.payload);
+  }
+
+  /**
+   * Creates a new schedule
+   */
+  async createSchedule(id, title, namespace, actionType, targetId, scheduleFor, identity, payload) {
+    const {
+      id: scheduleId
+    } = parseIdentifier(id);
+    const scheduledAction = {
+      id: scheduleId,
+      title,
+      namespace,
+      actionType,
+      targetId,
+      scheduledBy: {
+        id: identity.id,
+        type: identity.type,
+        displayName: identity.displayName
+      },
+      scheduledFor: scheduleFor,
+      payload
+    };
+
+    // Create CMS entry
+    const createResult = await this.createEntryUseCase.execute(this.model, {
+      id: scheduleId,
+      values: scheduledAction
+    });
+    if (createResult.isFail()) {
+      return Result.fail(new ScheduledActionPersistenceError(new Error(createResult.error.message)));
+    }
+
+    // Create EventBridge schedule
+    try {
+      await this.schedulerService.create({
+        id: scheduleId,
+        scheduleFor: new Date(scheduleFor)
+      });
+    } catch (error) {
+      // Rollback - delete CMS entry if EventBridge fails
+      console.error(`Failed to create EventBridge schedule: ${scheduleId}. Rolling back...`);
+      await this.deleteEntryUseCase.execute(this.model, scheduleId, {
+        force: true,
+        permanently: true
+      });
+      return Result.fail(new SchedulerServiceError(error));
+    }
+    return Result.ok(scheduledAction);
+  }
+
+  /**
+   * Updates an existing schedule (reschedule)
+   */
+  async reschedule(existing, scheduleFor, identity, payload) {
+    // Make sure we don't unset the existing payload.
+    if (!payload && existing.payload) {
+      payload = existing.payload;
+    }
+
+    // Update CMS entry
+    const existingEntryId = ScheduledActionIdWithVersion.from(existing.id);
+    const updateResult = await this.updateEntryUseCase.execute(this.model, existingEntryId, {
+      values: {
+        scheduledBy: {
+          id: identity.id,
+          type: identity.type,
+          displayName: identity.displayName
+        },
+        scheduledFor: scheduleFor,
+        payload
+      }
+    });
+    if (updateResult.isFail()) {
+      return Result.fail(new ScheduledActionPersistenceError(new Error(updateResult.error.message)));
+    }
+
+    // Update EventBridge schedule
+    try {
+      await this.schedulerService.update({
+        id: existing.id,
+        scheduleFor: new Date(scheduleFor)
+      });
+    } catch (error) {
+      return Result.fail(new SchedulerServiceError(error));
+    }
+    return Result.ok({
+      ...existing,
+      scheduledBy: {
+        id: identity.id,
+        type: identity.type,
+        displayName: identity.displayName
+      },
+      scheduledFor: scheduleFor,
+      payload
+    });
+  }
+}
+export const ScheduleActionUseCase = UseCaseAbstraction.createImplementation({
+  implementation: ScheduleActionUseCaseImpl,
+  dependencies: [IdentityContext, ScheduledActionModel, SchedulerService, GetScheduledActionUseCase, CreateEntryUseCase, UpdateEntryUseCase, DeleteEntryUseCase]
+});
+
+//# sourceMappingURL=ScheduleActionUseCase.js.map

package/features/ScheduleAction/ScheduleActionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","IdentityContext","CreateEntryUseCase","UpdateEntryUseCase","DeleteEntryUseCase","parseIdentifier","ScheduleActionUseCase","UseCaseAbstraction","GetScheduledActionUseCase","ScheduledActionModel","SchedulerService","InvalidScheduleDateError","ScheduledActionPersistenceError","SchedulerServiceError","ScheduledActionId","ScheduledActionIdWithVersion","isValidDate","ScheduleActionUseCaseImpl","constructor","identityContext","model","schedulerService","getScheduledAction","createEntryUseCase","updateEntryUseCase","deleteEntryUseCase","execute","params","identity","getIdentity","scheduleFor","fail","actionId","from","scheduleId","existingResult","isFail","error","code","createSchedule","title","namespace","actionType","targetId","payload","scheduledAction","value","reschedule","id","scheduledBy","type","displayName","scheduledFor","createResult","values","Error","message","create","Date","console","force","permanently","ok","existing","existingEntryId","updateResult","update","createImplementation","implementation","dependencies"],"sources":["ScheduleActionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { ScheduleActionUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetScheduledActionUseCase } from \"~/features/GetScheduledAction/abstractions.js\";\nimport type { Identity, IScheduledAction } from \"~/shared/abstractions.js\";\nimport { ScheduledActionModel, SchedulerService } from \"~/shared/abstractions.js\";\nimport {\n    InvalidScheduleDateError,\n    ScheduledActionPersistenceError,\n    SchedulerServiceError\n} from \"~/domain/errors.js\";\nimport { ScheduledActionId } from \"~/domain/ScheduledActionId.js\";\nimport { ScheduledActionIdWithVersion } from \"~/domain/ScheduledActionIdWithVersion.js\";\nimport { isValidDate } from \"~/domain/isValidDate.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * Schedules an action for future execution\n *\n * Flow:\n * 1. Generate unique schedule ID from namespace+actionType+targetId\n * 2. Check if schedule already exists (for rescheduling logic)\n * 3. If exists: UPDATE schedule entry + EventBridge schedule\n * 4. If new: CREATE schedule entry + EventBridge schedule\n * 5. Rollback schedule entry if EventBridge fails\n *\n * Note: Does NOT handle immediate execution - apps use direct use cases for that\n */\nclass ScheduleActionUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private model: ScheduledActionModel.Interface,\n        private schedulerService: SchedulerService.Interface,\n        private getScheduledAction: GetScheduledActionUseCase.Interface,\n        private createEntryUseCase: CreateEntryUseCase.Interface,\n        private updateEntryUseCase: UpdateEntryUseCase.Interface,\n        private deleteEntryUseCase: DeleteEntryUseCase.Interface\n    ) {}\n\n    async execute<T extends GenericRecord>(\n        params: UseCaseAbstraction.Params<T>\n    ): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n\n        if (!isValidDate(params.scheduleFor)) {\n            return Result.fail(new InvalidScheduleDateError(params.scheduleFor));\n        }\n\n        // Generate unique schedule ID\n        const actionId = ScheduledActionId.from(params);\n        const scheduleId = ScheduledActionIdWithVersion.from(actionId);\n\n        const existingResult = await this.getScheduledAction.execute(scheduleId);\n\n        if (existingResult.isFail()) {\n            const error = existingResult.error;\n\n            // NotFound means the action was not yet scheduled\n            if (error.code === \"Scheduler/ScheduledAction/NotFound\") {\n                return this.createSchedule(\n                    scheduleId,\n                    params.title,\n                    params.namespace,\n                    params.actionType,\n                    params.targetId,\n                    params.scheduleFor,\n                    identity,\n                    params.payload\n                );\n            }\n\n            if (error.code === \"Scheduler/ScheduledAction/PersistenceError\") {\n                return Result.fail(error);\n            }\n        }\n\n        // Reschedule existing action\n        const scheduledAction = existingResult.value;\n\n        return this.reschedule(scheduledAction, params.scheduleFor, identity, params.payload);\n    }\n\n    /**\n     * Creates a new schedule\n     */\n    private async createSchedule<T extends GenericRecord>(\n        id: string,\n        title: string,\n        namespace: string,\n        actionType: string,\n        targetId: string,\n        scheduleFor: string,\n        identity: Identity,\n        payload: T\n    ): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>> {\n        const { id: scheduleId } = parseIdentifier(id);\n\n        const scheduledAction: IScheduledAction<T> = {\n            id: scheduleId,\n            title,\n            namespace,\n            actionType,\n            targetId,\n            scheduledBy: {\n                id: identity.id,\n                type: identity.type,\n                displayName: identity.displayName\n            },\n            scheduledFor: scheduleFor,\n            payload\n        };\n\n        // Create CMS entry\n        const createResult = await this.createEntryUseCase.execute<IScheduledAction<T>>(\n            this.model,\n            {\n                id: scheduleId,\n                values: scheduledAction\n            }\n        );\n\n        if (createResult.isFail()) {\n            return Result.fail(\n                new ScheduledActionPersistenceError(new Error(createResult.error.message))\n            );\n        }\n\n        // Create EventBridge schedule\n        try {\n            await this.schedulerService.create({\n                id: scheduleId,\n                scheduleFor: new Date(scheduleFor)\n            });\n        } catch (error) {\n            // Rollback - delete CMS entry if EventBridge fails\n            console.error(`Failed to create EventBridge schedule: ${scheduleId}. Rolling back...`);\n\n            await this.deleteEntryUseCase.execute(this.model, scheduleId, {\n                force: true,\n                permanently: true\n            });\n\n            return Result.fail(new SchedulerServiceError(error as Error));\n        }\n\n        return Result.ok(scheduledAction);\n    }\n\n    /**\n     * Updates an existing schedule (reschedule)\n     */\n    private async reschedule<T extends GenericRecord>(\n        existing: IScheduledAction<T>,\n        scheduleFor: string,\n        identity: Identity,\n        payload?: any\n    ): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>> {\n        // Make sure we don't unset the existing payload.\n        if (!payload && existing.payload) {\n            payload = existing.payload;\n        }\n\n        // Update CMS entry\n        const existingEntryId = ScheduledActionIdWithVersion.from(existing.id);\n        const updateResult = await this.updateEntryUseCase.execute<IScheduledAction<T>>(\n            this.model,\n            existingEntryId,\n            {\n                values: {\n                    scheduledBy: {\n                        id: identity.id,\n                        type: identity.type,\n                        displayName: identity.displayName\n                    },\n                    scheduledFor: scheduleFor,\n                    payload\n                }\n            }\n        );\n\n        if (updateResult.isFail()) {\n            return Result.fail(\n                new ScheduledActionPersistenceError(new Error(updateResult.error.message))\n            );\n        }\n\n        // Update EventBridge schedule\n        try {\n            await this.schedulerService.update({\n                id: existing.id,\n                scheduleFor: new Date(scheduleFor)\n            });\n        } catch (error) {\n            return Result.fail(new SchedulerServiceError(error as Error));\n        }\n\n        return Result.ok({\n            ...existing,\n            scheduledBy: {\n                id: identity.id,\n                type: identity.type,\n                displayName: identity.displayName\n            },\n            scheduledFor: scheduleFor,\n            payload\n        });\n    }\n}\n\nexport const ScheduleActionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ScheduleActionUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        ScheduledActionModel,\n        SchedulerService,\n        GetScheduledActionUseCase,\n        CreateEntryUseCase,\n        UpdateEntryUseCase,\n        DeleteEntryUseCase\n    ]\n});\n"],"mappings":"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","ignoreList":[]}