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

package/features/CancelScheduledAction/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CancelScheduledAction Feature
+ *
+ * Provides the ability to cancel a scheduled action.
+ * Removes both the EventBridge schedule and the CMS entry.
+ */
+export declare const CancelScheduledActionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/CancelScheduledAction/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { CancelScheduledActionUseCase } from "./CancelScheduledActionUseCase.js";
+
+/**
+ * CancelScheduledAction Feature
+ *
+ * Provides the ability to cancel a scheduled action.
+ * Removes both the EventBridge schedule and the CMS entry.
+ */
+export const CancelScheduledActionFeature = createFeature({
+  name: "CancelScheduledAction",
+  register(container) {
+    container.register(CancelScheduledActionUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/CancelScheduledAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CancelScheduledActionUseCase","CancelScheduledActionFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CancelScheduledActionUseCase } from \"./CancelScheduledActionUseCase.js\";\n\n/**\n * CancelScheduledAction Feature\n *\n * Provides the ability to cancel a scheduled action.\n * Removes both the EventBridge schedule and the CMS entry.\n */\nexport const CancelScheduledActionFeature = createFeature({\n    name: \"CancelScheduledAction\",\n    register(container) {\n        container.register(CancelScheduledActionUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,4BAA4B;;AAErC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,4BAA4B,GAAGF,aAAa,CAAC;EACtDG,IAAI,EAAE,uBAAuB;EAC7BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,4BAA4B,CAAC;EACpD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/CancelScheduledAction/index.d.ts

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

package/features/CancelScheduledAction/index.js

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

package/features/CancelScheduledAction/index.js.map

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

package/features/ExecuteScheduledAction/ExecuteScheduledActionUseCase.d.ts

@@ -0,0 +1,33 @@
+import { Result } from "@webiny/feature/api";
+import { ExecuteScheduledActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetScheduledActionUseCase } from "../../features/GetScheduledAction/abstractions.js";
+import { ScheduledActionHandler, ScheduledActionModel } from "../../shared/abstractions.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+/**
+ * Executes a scheduled action
+ *
+ * Flow:
+ * 1. Load scheduled action from CMS
+ * 2. Find registered handler for namespace + actionType
+ * 3. Execute handler
+ * 4. Delete schedule entry on success
+ * 5. Update entry with error on failure (for debugging/audit)
+ */
+declare class ExecuteScheduledActionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getScheduledActionUseCase;
+    private actionHandler;
+    private deleteEntryUseCase;
+    private updateEntryUseCase;
+    private model;
+    private identityContext;
+    constructor(getScheduledActionUseCase: GetScheduledActionUseCase.Interface, actionHandler: ScheduledActionHandler.Interface, deleteEntryUseCase: DeleteEntryUseCase.Interface, updateEntryUseCase: UpdateEntryUseCase.Interface, model: ScheduledActionModel.Interface, identityContext: IdentityContext.Interface);
+    execute<T extends GenericRecord>(id: string): Promise<Result<void, UseCaseAbstraction.Error>>;
+    private executeAction;
+}
+export declare const ExecuteScheduledActionUseCase: typeof ExecuteScheduledActionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IExecuteScheduledActionUseCase>;
+};
+export {};

package/features/ExecuteScheduledAction/ExecuteScheduledActionUseCase.js

@@ -0,0 +1,106 @@
+import { Result } from "@webiny/feature/api";
+import { ExecuteScheduledActionUseCase as UseCaseAbstraction, ExecutionFailedError, HandlerNotFoundError } from "./abstractions.js";
+import { GetScheduledActionUseCase } from "../GetScheduledAction/abstractions.js";
+import { ScheduledActionHandler, ScheduledActionModel } from "../../shared/abstractions.js";
+import { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from "../../domain/errors.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { ScheduledActionIdWithVersion } from "../../domain/ScheduledActionIdWithVersion.js";
+import { AuthenticatedIdentity, IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+
+/**
+ * Executes a scheduled action
+ *
+ * Flow:
+ * 1. Load scheduled action from CMS
+ * 2. Find registered handler for namespace + actionType
+ * 3. Execute handler
+ * 4. Delete schedule entry on success
+ * 5. Update entry with error on failure (for debugging/audit)
+ */
+class ExecuteScheduledActionUseCaseImpl {
+  constructor(getScheduledActionUseCase, actionHandler, deleteEntryUseCase, updateEntryUseCase, model, identityContext) {
+    this.getScheduledActionUseCase = getScheduledActionUseCase;
+    this.actionHandler = actionHandler;
+    this.deleteEntryUseCase = deleteEntryUseCase;
+    this.updateEntryUseCase = updateEntryUseCase;
+    this.model = model;
+    this.identityContext = identityContext;
+  }
+  async execute(id) {
+    // return this.identityContext.withoutAuthorization(async () => {
+    return this.executeAction(id);
+    // });
+  }
+  async executeAction(id) {
+    // Load scheduled action
+    const getResult = await this.getScheduledActionUseCase.execute(id);
+    if (getResult.isFail()) {
+      const error = getResult.error;
+      if (error.code === "Scheduler/ScheduledAction/NotFound") {
+        return Result.fail(new ScheduledActionNotFoundError(id));
+      }
+      return Result.fail(error);
+    }
+    const scheduledAction = getResult.value;
+
+    /**
+     * When executing the scheduled action, we need a user which has access to perform the action.
+     * We will set a user which created the scheduled action as the execution user.
+     */
+    const scheduledBy = scheduledAction.scheduledBy;
+    this.identityContext.setIdentity(new AuthenticatedIdentity({
+      id: scheduledBy.id,
+      type: scheduledBy.type,
+      displayName: scheduledBy.displayName ?? "",
+      context: {
+        canAccessTenant: true
+      }
+    }));
+    const scheduleId = ScheduledActionIdWithVersion.from(id);
+
+    // Check if the handler can handle this action
+    if (!this.actionHandler.canHandle(scheduledAction.namespace, scheduledAction.actionType)) {
+      const error = new HandlerNotFoundError(scheduledAction.namespace, scheduledAction.actionType);
+
+      // Update entry with error for debugging
+      await this.updateEntryUseCase.execute(this.model, scheduleId, {
+        values: {
+          error: error.message
+        }
+      });
+      return Result.fail(error);
+    }
+
+    // Execute handler
+    try {
+      await this.actionHandler.handle(scheduledAction);
+
+      // Delete schedule entry on success
+      const deleteResult = await this.deleteEntryUseCase.execute(this.model, scheduleId, {
+        force: true,
+        permanently: true
+      });
+      if (deleteResult.isFail()) {
+        return Result.fail(new ScheduledActionPersistenceError(new Error(deleteResult.error.message)));
+      }
+      return Result.ok();
+    } catch (error) {
+      const executionError = new ExecutionFailedError(`Failed to execute scheduled action: ${error.message}`, error);
+
+      // Update entry with error for debugging
+      await this.updateEntryUseCase.execute(this.model, scheduleId, {
+        values: {
+          error: executionError.message
+        }
+      });
+      return Result.fail(executionError);
+    }
+  }
+}
+export const ExecuteScheduledActionUseCase = UseCaseAbstraction.createImplementation({
+  implementation: ExecuteScheduledActionUseCaseImpl,
+  dependencies: [GetScheduledActionUseCase, ScheduledActionHandler, DeleteEntryUseCase, UpdateEntryUseCase, ScheduledActionModel, IdentityContext]
+});
+
+//# sourceMappingURL=ExecuteScheduledActionUseCase.js.map

package/features/ExecuteScheduledAction/ExecuteScheduledActionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ExecuteScheduledActionUseCase","UseCaseAbstraction","ExecutionFailedError","HandlerNotFoundError","GetScheduledActionUseCase","ScheduledActionHandler","ScheduledActionModel","ScheduledActionNotFoundError","ScheduledActionPersistenceError","DeleteEntryUseCase","UpdateEntryUseCase","ScheduledActionIdWithVersion","AuthenticatedIdentity","IdentityContext","ExecuteScheduledActionUseCaseImpl","constructor","getScheduledActionUseCase","actionHandler","deleteEntryUseCase","updateEntryUseCase","model","identityContext","execute","id","executeAction","getResult","isFail","error","code","fail","scheduledAction","value","scheduledBy","setIdentity","type","displayName","context","canAccessTenant","scheduleId","from","canHandle","namespace","actionType","values","message","handle","deleteResult","force","permanently","Error","ok","executionError","createImplementation","implementation","dependencies"],"sources":["ExecuteScheduledActionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ExecuteScheduledActionUseCase as UseCaseAbstraction,\n    ExecutionFailedError,\n    HandlerNotFoundError\n} from \"./abstractions.js\";\nimport { GetScheduledActionUseCase } from \"~/features/GetScheduledAction/abstractions.js\";\nimport {\n    type IScheduledAction,\n    ScheduledActionHandler,\n    ScheduledActionModel\n} from \"~/shared/abstractions.js\";\nimport { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from \"~/domain/errors.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { ScheduledActionIdWithVersion } from \"~/domain/ScheduledActionIdWithVersion.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport {\n    AuthenticatedIdentity,\n    IdentityContext\n} from \"@webiny/api-core/features/security/IdentityContext/index.js\";\n\n/**\n * Executes a scheduled action\n *\n * Flow:\n * 1. Load scheduled action from CMS\n * 2. Find registered handler for namespace + actionType\n * 3. Execute handler\n * 4. Delete schedule entry on success\n * 5. Update entry with error on failure (for debugging/audit)\n */\nclass ExecuteScheduledActionUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private getScheduledActionUseCase: GetScheduledActionUseCase.Interface,\n        private actionHandler: ScheduledActionHandler.Interface,\n        private deleteEntryUseCase: DeleteEntryUseCase.Interface,\n        private updateEntryUseCase: UpdateEntryUseCase.Interface,\n        private model: ScheduledActionModel.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    public async execute<T extends GenericRecord>(\n        id: string\n    ): Promise<Result<void, UseCaseAbstraction.Error>> {\n        // return this.identityContext.withoutAuthorization(async () => {\n        return this.executeAction<T>(id);\n        // });\n    }\n\n    private async executeAction<T extends GenericRecord>(\n        id: string\n    ): Promise<Result<void, UseCaseAbstraction.Error>> {\n        // Load scheduled action\n        const getResult = await this.getScheduledActionUseCase.execute<T>(id);\n\n        if (getResult.isFail()) {\n            const error = getResult.error;\n\n            if (error.code === \"Scheduler/ScheduledAction/NotFound\") {\n                return Result.fail(new ScheduledActionNotFoundError(id));\n            }\n\n            return Result.fail(error);\n        }\n        const scheduledAction = getResult.value;\n\n        /**\n         * When executing the scheduled action, we need a user which has access to perform the action.\n         * We will set a user which created the scheduled action as the execution user.\n         */\n        const scheduledBy = scheduledAction.scheduledBy;\n        this.identityContext.setIdentity(\n            new AuthenticatedIdentity({\n                id: scheduledBy.id,\n                type: scheduledBy.type,\n                displayName: scheduledBy.displayName ?? \"\",\n                context: {\n                    canAccessTenant: true\n                }\n            })\n        );\n\n        const scheduleId = ScheduledActionIdWithVersion.from(id);\n\n        // Check if the handler can handle this action\n        if (!this.actionHandler.canHandle(scheduledAction.namespace, scheduledAction.actionType)) {\n            const error = new HandlerNotFoundError(\n                scheduledAction.namespace,\n                scheduledAction.actionType\n            );\n\n            // Update entry with error for debugging\n            await this.updateEntryUseCase.execute<IScheduledAction<T>>(this.model, scheduleId, {\n                values: {\n                    error: error.message\n                }\n            });\n\n            return Result.fail(error);\n        }\n\n        // Execute handler\n        try {\n            await this.actionHandler.handle(scheduledAction);\n\n            // Delete schedule entry on success\n            const deleteResult = await this.deleteEntryUseCase.execute(this.model, scheduleId, {\n                force: true,\n                permanently: true\n            });\n\n            if (deleteResult.isFail()) {\n                return Result.fail(\n                    new ScheduledActionPersistenceError(new Error(deleteResult.error.message))\n                );\n            }\n\n            return Result.ok();\n        } catch (error) {\n            const executionError = new ExecutionFailedError(\n                `Failed to execute scheduled action: ${(error as Error).message}`,\n                error as Error\n            );\n\n            // Update entry with error for debugging\n            await this.updateEntryUseCase.execute<IScheduledAction<T>>(this.model, scheduleId, {\n                values: {\n                    error: executionError.message\n                }\n            });\n\n            return Result.fail(executionError);\n        }\n    }\n}\n\nexport const ExecuteScheduledActionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ExecuteScheduledActionUseCaseImpl,\n    dependencies: [\n        GetScheduledActionUseCase,\n        ScheduledActionHandler,\n        DeleteEntryUseCase,\n        UpdateEntryUseCase,\n        ScheduledActionModel,\n        IdentityContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/ExecuteScheduledAction/ScheduledActionHandlerComposite.d.ts

@@ -0,0 +1,19 @@
+import { IScheduledAction, ScheduledActionHandler } from "../../shared/abstractions.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * Composite handler that iterates through all registered handlers
+ * to find one that can handle the given namespace + actionType combination.
+ *
+ * This is registered as a composite via container.registerComposite(),
+ * and the DI container will automatically inject all registered handlers.
+ */
+declare class ScheduledActionHandlerCompositeImpl implements ScheduledActionHandler.Interface {
+    private handlers;
+    constructor(handlers: ScheduledActionHandler.Interface[]);
+    canHandle(namespace: string, actionType: string): boolean;
+    handle<T extends GenericRecord>(action: IScheduledAction<T>): Promise<void>;
+}
+export declare const ScheduledActionHandlerComposite: typeof ScheduledActionHandlerCompositeImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/shared/abstractions.js").IScheduledActionHandler>;
+};
+export {};

package/features/ExecuteScheduledAction/ScheduledActionHandlerComposite.js

@@ -0,0 +1,32 @@
+import { ScheduledActionHandler } from "../../shared/abstractions.js";
+/**
+ * Composite handler that iterates through all registered handlers
+ * to find one that can handle the given namespace + actionType combination.
+ *
+ * This is registered as a composite via container.registerComposite(),
+ * and the DI container will automatically inject all registered handlers.
+ */
+class ScheduledActionHandlerCompositeImpl {
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+  canHandle(namespace, actionType) {
+    return this.handlers.some(handler => handler.canHandle(namespace, actionType));
+  }
+  async handle(action) {
+    const handler = this.handlers.find(h => h.canHandle(action.namespace, action.actionType));
+    if (!handler) {
+      console.log(`No handler found for namespace "${action.namespace}" and actionType "${action.actionType}"`);
+      return;
+    }
+    await handler.handle(action);
+  }
+}
+export const ScheduledActionHandlerComposite = ScheduledActionHandler.createComposite({
+  implementation: ScheduledActionHandlerCompositeImpl,
+  dependencies: [[ScheduledActionHandler, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=ScheduledActionHandlerComposite.js.map

package/features/ExecuteScheduledAction/ScheduledActionHandlerComposite.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ScheduledActionHandler","ScheduledActionHandlerCompositeImpl","constructor","handlers","canHandle","namespace","actionType","some","handler","handle","action","find","h","console","log","ScheduledActionHandlerComposite","createComposite","implementation","dependencies","multiple"],"sources":["ScheduledActionHandlerComposite.ts"],"sourcesContent":["import { IScheduledAction, ScheduledActionHandler } from \"~/shared/abstractions.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * Composite handler that iterates through all registered handlers\n * to find one that can handle the given namespace + actionType combination.\n *\n * This is registered as a composite via container.registerComposite(),\n * and the DI container will automatically inject all registered handlers.\n */\nclass ScheduledActionHandlerCompositeImpl implements ScheduledActionHandler.Interface {\n    public constructor(private handlers: ScheduledActionHandler.Interface[]) {}\n\n    public canHandle(namespace: string, actionType: string): boolean {\n        return this.handlers.some(handler => handler.canHandle(namespace, actionType));\n    }\n\n    public async handle<T extends GenericRecord>(action: IScheduledAction<T>): Promise<void> {\n        const handler = this.handlers.find(h => h.canHandle(action.namespace, action.actionType));\n\n        if (!handler) {\n            console.log(\n                `No handler found for namespace \"${action.namespace}\" and actionType \"${action.actionType}\"`\n            );\n            return;\n        }\n\n        await handler.handle(action);\n    }\n}\n\nexport const ScheduledActionHandlerComposite = ScheduledActionHandler.createComposite({\n    implementation: ScheduledActionHandlerCompositeImpl,\n    dependencies: [[ScheduledActionHandler, { multiple: true }]]\n});\n"],"mappings":"AAAA,SAA2BA,sBAAsB;AAGjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mCAAmC,CAA6C;EAC3EC,WAAWA,CAASC,QAA4C,EAAE;IAAA,KAA9CA,QAA4C,GAA5CA,QAA4C;EAAG;EAEnEC,SAASA,CAACC,SAAiB,EAAEC,UAAkB,EAAW;IAC7D,OAAO,IAAI,CAACH,QAAQ,CAACI,IAAI,CAACC,OAAO,IAAIA,OAAO,CAACJ,SAAS,CAACC,SAAS,EAAEC,UAAU,CAAC,CAAC;EAClF;EAEA,MAAaG,MAAMA,CAA0BC,MAA2B,EAAiB;IACrF,MAAMF,OAAO,GAAG,IAAI,CAACL,QAAQ,CAACQ,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACR,SAAS,CAACM,MAAM,CAACL,SAAS,EAAEK,MAAM,CAACJ,UAAU,CAAC,CAAC;IAEzF,IAAI,CAACE,OAAO,EAAE;MACVK,OAAO,CAACC,GAAG,CACP,mCAAmCJ,MAAM,CAACL,SAAS,qBAAqBK,MAAM,CAACJ,UAAU,GAC7F,CAAC;MACD;IACJ;IAEA,MAAME,OAAO,CAACC,MAAM,CAACC,MAAM,CAAC;EAChC;AACJ;AAEA,OAAO,MAAMK,+BAA+B,GAAGf,sBAAsB,CAACgB,eAAe,CAAC;EAClFC,cAAc,EAAEhB,mCAAmC;EACnDiB,YAAY,EAAE,CAAC,CAAClB,sBAAsB,EAAE;IAAEmB,QAAQ,EAAE;EAAK,CAAC,CAAC;AAC/D,CAAC,CAAC","ignoreList":[]}

package/features/ExecuteScheduledAction/abstractions.d.ts

@@ -0,0 +1,46 @@
+import { Result } from "@webiny/feature/api";
+import { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from "../../domain/errors.js";
+/**
+ * ExecuteScheduledActionUseCase - Execute a scheduled action
+ *
+ * This is triggered by EventBridge when a schedule fires.
+ * Finds the appropriate handler based on namespace + actionType and executes it.
+ *
+ * Flow:
+ * 1. Load scheduled action from CMS
+ * 2. Find registered handler for namespace + actionType
+ * 3. Execute handler
+ * 4. Delete schedule entry on success
+ * 5. Update entry with error on failure
+ */
+export interface IExecuteScheduledActionErrors {
+    notFound: ScheduledActionNotFoundError;
+    persistence: ScheduledActionPersistenceError;
+    handlerNotFound: HandlerNotFoundError;
+    executionFailed: ExecutionFailedError;
+}
+type ExecuteScheduledActionError = IExecuteScheduledActionErrors[keyof IExecuteScheduledActionErrors];
+export interface IExecuteScheduledActionUseCase {
+    execute(scheduleId: string): Promise<Result<void, ExecuteScheduledActionError>>;
+}
+export declare const ExecuteScheduledActionUseCase: import("@webiny/di").Abstraction<IExecuteScheduledActionUseCase>;
+export declare namespace ExecuteScheduledActionUseCase {
+    type Interface = IExecuteScheduledActionUseCase;
+    type Error = ExecuteScheduledActionError;
+}
+/**
+ * Handler not found error
+ */
+export declare class HandlerNotFoundError extends Error {
+    readonly code: "Scheduler/Handler/NotFound";
+    constructor(namespace: string, actionType: string);
+}
+/**
+ * Execution failed error
+ */
+export declare class ExecutionFailedError extends Error {
+    readonly originalError?: Error | undefined;
+    readonly code: "Scheduler/Execution/Failed";
+    constructor(message: string, originalError?: Error | undefined);
+}
+export {};

package/features/ExecuteScheduledAction/abstractions.js

@@ -0,0 +1,41 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ExecuteScheduledActionUseCase - Execute a scheduled action
+ *
+ * This is triggered by EventBridge when a schedule fires.
+ * Finds the appropriate handler based on namespace + actionType and executes it.
+ *
+ * Flow:
+ * 1. Load scheduled action from CMS
+ * 2. Find registered handler for namespace + actionType
+ * 3. Execute handler
+ * 4. Delete schedule entry on success
+ * 5. Update entry with error on failure
+ */
+
+export const ExecuteScheduledActionUseCase = createAbstraction("ExecuteScheduledActionUseCase");
+/**
+ * Handler not found error
+ */
+export class HandlerNotFoundError extends Error {
+  code = "Scheduler/Handler/NotFound";
+  constructor(namespace, actionType) {
+    super(`No handler registered for namespace "${namespace}" and actionType "${actionType}"`);
+    this.name = "HandlerNotFoundError";
+  }
+}
+
+/**
+ * Execution failed error
+ */
+export class ExecutionFailedError extends Error {
+  code = "Scheduler/Execution/Failed";
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "ExecutionFailedError";
+  }
+}
+
+//# sourceMappingURL=abstractions.js.map

package/features/ExecuteScheduledAction/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ExecuteScheduledActionUseCase","HandlerNotFoundError","Error","code","constructor","namespace","actionType","name","ExecutionFailedError","message","originalError"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from \"~/domain/errors.js\";\n\n/**\n * ExecuteScheduledActionUseCase - Execute a scheduled action\n *\n * This is triggered by EventBridge when a schedule fires.\n * Finds the appropriate handler based on namespace + actionType and executes it.\n *\n * Flow:\n * 1. Load scheduled action from CMS\n * 2. Find registered handler for namespace + actionType\n * 3. Execute handler\n * 4. Delete schedule entry on success\n * 5. Update entry with error on failure\n */\n\nexport interface IExecuteScheduledActionErrors {\n    notFound: ScheduledActionNotFoundError;\n    persistence: ScheduledActionPersistenceError;\n    handlerNotFound: HandlerNotFoundError;\n    executionFailed: ExecutionFailedError;\n}\n\ntype ExecuteScheduledActionError =\n    IExecuteScheduledActionErrors[keyof IExecuteScheduledActionErrors];\n\nexport interface IExecuteScheduledActionUseCase {\n    execute(scheduleId: string): Promise<Result<void, ExecuteScheduledActionError>>;\n}\n\nexport const ExecuteScheduledActionUseCase = createAbstraction<IExecuteScheduledActionUseCase>(\n    \"ExecuteScheduledActionUseCase\"\n);\n\nexport namespace ExecuteScheduledActionUseCase {\n    export type Interface = IExecuteScheduledActionUseCase;\n    export type Error = ExecuteScheduledActionError;\n}\n\n/**\n * Handler not found error\n */\nexport class HandlerNotFoundError extends Error {\n    readonly code = \"Scheduler/Handler/NotFound\" as const;\n\n    constructor(namespace: string, actionType: string) {\n        super(`No handler registered for namespace \"${namespace}\" and actionType \"${actionType}\"`);\n        this.name = \"HandlerNotFoundError\";\n    }\n}\n\n/**\n * Execution failed error\n */\nexport class ExecutionFailedError extends Error {\n    readonly code = \"Scheduler/Execution/Failed\" as const;\n\n    constructor(\n        message: string,\n        public readonly originalError?: Error\n    ) {\n        super(message);\n        this.name = \"ExecutionFailedError\";\n    }\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAIvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgBA,OAAO,MAAMC,6BAA6B,GAAGD,iBAAiB,CAC1D,+BACJ,CAAC;AAOD;AACA;AACA;AACA,OAAO,MAAME,oBAAoB,SAASC,KAAK,CAAC;EACnCC,IAAI,GAAG,4BAA4B;EAE5CC,WAAWA,CAACC,SAAiB,EAAEC,UAAkB,EAAE;IAC/C,KAAK,CAAC,wCAAwCD,SAAS,qBAAqBC,UAAU,GAAG,CAAC;IAC1F,IAAI,CAACC,IAAI,GAAG,sBAAsB;EACtC;AACJ;;AAEA;AACA;AACA;AACA,OAAO,MAAMC,oBAAoB,SAASN,KAAK,CAAC;EACnCC,IAAI,GAAG,4BAA4B;EAE5CC,WAAWA,CACPK,OAAe,EACCC,aAAqB,EACvC;IACE,KAAK,CAACD,OAAO,CAAC;IAAC,KAFCC,aAAqB,GAArBA,aAAqB;IAGrC,IAAI,CAACH,IAAI,GAAG,sBAAsB;EACtC;AACJ","ignoreList":[]}

package/features/ExecuteScheduledAction/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ExecuteScheduledAction Feature
+ *
+ * Provides the ability to execute a scheduled action when triggered by EventBridge.
+ * Finds the appropriate handler and executes it, then cleans up the schedule entry.
+ */
+export declare const ExecuteScheduledActionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/ExecuteScheduledAction/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/api";
+import { ExecuteScheduledActionUseCase } from "./ExecuteScheduledActionUseCase.js";
+import { ScheduledActionHandlerComposite } from "./ScheduledActionHandlerComposite.js";
+
+/**
+ * ExecuteScheduledAction Feature
+ *
+ * Provides the ability to execute a scheduled action when triggered by EventBridge.
+ * Finds the appropriate handler and executes it, then cleans up the schedule entry.
+ */
+export const ExecuteScheduledActionFeature = createFeature({
+  name: "ExecuteScheduledAction",
+  register(container) {
+    container.register(ExecuteScheduledActionUseCase);
+    container.registerComposite(ScheduledActionHandlerComposite);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/ExecuteScheduledAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ExecuteScheduledActionUseCase","ScheduledActionHandlerComposite","ExecuteScheduledActionFeature","name","register","container","registerComposite"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ExecuteScheduledActionUseCase } from \"./ExecuteScheduledActionUseCase.js\";\nimport { ScheduledActionHandlerComposite } from \"~/features/ExecuteScheduledAction/ScheduledActionHandlerComposite.js\";\n\n/**\n * ExecuteScheduledAction Feature\n *\n * Provides the ability to execute a scheduled action when triggered by EventBridge.\n * Finds the appropriate handler and executes it, then cleans up the schedule entry.\n */\nexport const ExecuteScheduledActionFeature = createFeature({\n    name: \"ExecuteScheduledAction\",\n    register(container) {\n        container.register(ExecuteScheduledActionUseCase);\n        container.registerComposite(ScheduledActionHandlerComposite);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,6BAA6B;AACtC,SAASC,+BAA+B;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,6BAA6B,GAAGH,aAAa,CAAC;EACvDI,IAAI,EAAE,wBAAwB;EAC9BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,6BAA6B,CAAC;IACjDK,SAAS,CAACC,iBAAiB,CAACL,+BAA+B,CAAC;EAChE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/ExecuteScheduledAction/index.d.ts

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

package/features/ExecuteScheduledAction/index.js

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

package/features/ExecuteScheduledAction/index.js.map

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

package/features/GetScheduledAction/GetScheduledActionUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { GetScheduledActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { IScheduledAction } from "../../shared/abstractions.js";
+import { ScheduledActionModel } from "../../shared/abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * Retrieves a scheduled action by its ID
+ *
+ * Flow:
+ * 1. Fetch schedule entry from CMS storage by ID
+ * 2. Return null if not found
+ * 3. Transform CMS entry to IScheduledAction format
+ */
+declare class GetScheduledActionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getEntryByIdUseCase;
+    private model;
+    constructor(getEntryByIdUseCase: GetEntryByIdUseCase.Interface, model: ScheduledActionModel.Interface);
+    execute<T extends GenericRecord>(id: string): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>>;
+}
+export declare const GetScheduledActionUseCase: typeof GetScheduledActionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetScheduledActionUseCase>;
+};
+export {};

package/features/GetScheduledAction/GetScheduledActionUseCase.js

@@ -0,0 +1,49 @@
+import { Result } from "@webiny/feature/api";
+import { GetScheduledActionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduledActionModel } from "../../shared/abstractions.js";
+import { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from "../../domain/errors.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { ScheduledActionIdWithVersion } from "../../domain/ScheduledActionIdWithVersion.js";
+/**
+ * Retrieves a scheduled action by its ID
+ *
+ * Flow:
+ * 1. Fetch schedule entry from CMS storage by ID
+ * 2. Return null if not found
+ * 3. Transform CMS entry to IScheduledAction format
+ */
+class GetScheduledActionUseCaseImpl {
+  constructor(getEntryByIdUseCase, model) {
+    this.getEntryByIdUseCase = getEntryByIdUseCase;
+    this.model = model;
+  }
+  async execute(id) {
+    // Get entry from CMS
+    const scheduleId = ScheduledActionIdWithVersion.from(id);
+    const entryResult = await this.getEntryByIdUseCase.execute(this.model, scheduleId);
+    if (entryResult.isFail()) {
+      if (entryResult.error.code === "Cms/Entry/NotFound") {
+        return Result.fail(new ScheduledActionNotFoundError(scheduleId));
+      }
+      return Result.fail(new ScheduledActionPersistenceError(entryResult.error));
+    }
+    const entry = entryResult.value;
+    return Result.ok({
+      id: entry.entryId,
+      namespace: entry.values.namespace,
+      actionType: entry.values.actionType,
+      targetId: entry.values.targetId,
+      scheduledBy: entry.values.scheduledBy,
+      scheduledFor: entry.values.scheduledFor,
+      payload: entry.values.payload,
+      title: entry.values.title,
+      error: entry.values.error
+    });
+  }
+}
+export const GetScheduledActionUseCase = UseCaseAbstraction.createImplementation({
+  implementation: GetScheduledActionUseCaseImpl,
+  dependencies: [GetEntryByIdUseCase, ScheduledActionModel]
+});
+
+//# sourceMappingURL=GetScheduledActionUseCase.js.map

package/features/GetScheduledAction/GetScheduledActionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetScheduledActionUseCase","UseCaseAbstraction","ScheduledActionModel","ScheduledActionNotFoundError","ScheduledActionPersistenceError","GetEntryByIdUseCase","ScheduledActionIdWithVersion","GetScheduledActionUseCaseImpl","constructor","getEntryByIdUseCase","model","execute","id","scheduleId","from","entryResult","isFail","error","code","fail","entry","value","ok","entryId","namespace","values","actionType","targetId","scheduledBy","scheduledFor","payload","title","createImplementation","implementation","dependencies"],"sources":["GetScheduledActionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetScheduledActionUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { IScheduledAction } from \"~/shared/abstractions.js\";\nimport { ScheduledActionModel } from \"~/shared/abstractions.js\";\nimport { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from \"~/domain/errors.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { ScheduledActionIdWithVersion } from \"~/domain/ScheduledActionIdWithVersion.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * Retrieves a scheduled action by its ID\n *\n * Flow:\n * 1. Fetch schedule entry from CMS storage by ID\n * 2. Return null if not found\n * 3. Transform CMS entry to IScheduledAction format\n */\nclass GetScheduledActionUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getEntryByIdUseCase: GetEntryByIdUseCase.Interface,\n        private model: ScheduledActionModel.Interface\n    ) {}\n\n    async execute<T extends GenericRecord>(\n        id: string\n    ): Promise<Result<IScheduledAction<T>, UseCaseAbstraction.Error>> {\n        // Get entry from CMS\n        const scheduleId = ScheduledActionIdWithVersion.from(id);\n        const entryResult = await this.getEntryByIdUseCase.execute<IScheduledAction<T>>(\n            this.model,\n            scheduleId\n        );\n\n        if (entryResult.isFail()) {\n            if (entryResult.error.code === \"Cms/Entry/NotFound\") {\n                return Result.fail(new ScheduledActionNotFoundError(scheduleId));\n            }\n\n            return Result.fail(new ScheduledActionPersistenceError(entryResult.error));\n        }\n\n        const entry = entryResult.value;\n\n        return Result.ok({\n            id: entry.entryId,\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            title: entry.values.title,\n            error: entry.values.error\n        });\n    }\n}\n\nexport const GetScheduledActionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetScheduledActionUseCaseImpl,\n    dependencies: [GetEntryByIdUseCase, ScheduledActionModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,yBAAyB,IAAIC,kBAAkB;AAExD,SAASC,oBAAoB;AAC7B,SAASC,4BAA4B,EAAEC,+BAA+B;AACtE,SAASC,mBAAmB,QAAQ,sEAAsE;AAC1G,SAASC,4BAA4B;AAGrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,6BAA6B,CAAyC;EACxEC,WAAWA,CACCC,mBAAkD,EAClDC,KAAqC,EAC/C;IAAA,KAFUD,mBAAkD,GAAlDA,mBAAkD;IAAA,KAClDC,KAAqC,GAArCA,KAAqC;EAC9C;EAEH,MAAMC,OAAOA,CACTC,EAAU,EACoD;IAC9D;IACA,MAAMC,UAAU,GAAGP,4BAA4B,CAACQ,IAAI,CAACF,EAAE,CAAC;IACxD,MAAMG,WAAW,GAAG,MAAM,IAAI,CAACN,mBAAmB,CAACE,OAAO,CACtD,IAAI,CAACD,KAAK,EACVG,UACJ,CAAC;IAED,IAAIE,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;MACtB,IAAID,WAAW,CAACE,KAAK,CAACC,IAAI,KAAK,oBAAoB,EAAE;QACjD,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAIhB,4BAA4B,CAACU,UAAU,CAAC,CAAC;MACpE;MAEA,OAAOd,MAAM,CAACoB,IAAI,CAAC,IAAIf,+BAA+B,CAACW,WAAW,CAACE,KAAK,CAAC,CAAC;IAC9E;IAEA,MAAMG,KAAK,GAAGL,WAAW,CAACM,KAAK;IAE/B,OAAOtB,MAAM,CAACuB,EAAE,CAAC;MACbV,EAAE,EAAEQ,KAAK,CAACG,OAAO;MACjBC,SAAS,EAAEJ,KAAK,CAACK,MAAM,CAACD,SAAS;MACjCE,UAAU,EAAEN,KAAK,CAACK,MAAM,CAACC,UAAU;MACnCC,QAAQ,EAAEP,KAAK,CAACK,MAAM,CAACE,QAAQ;MAC/BC,WAAW,EAAER,KAAK,CAACK,MAAM,CAACG,WAAW;MACrCC,YAAY,EAAET,KAAK,CAACK,MAAM,CAACI,YAAY;MACvCC,OAAO,EAAEV,KAAK,CAACK,MAAM,CAACK,OAAO;MAC7BC,KAAK,EAAEX,KAAK,CAACK,MAAM,CAACM,KAAK;MACzBd,KAAK,EAAEG,KAAK,CAACK,MAAM,CAACR;IACxB,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMjB,yBAAyB,GAAGC,kBAAkB,CAAC+B,oBAAoB,CAAC;EAC7EC,cAAc,EAAE1B,6BAA6B;EAC7C2B,YAAY,EAAE,CAAC7B,mBAAmB,EAAEH,oBAAoB;AAC5D,CAAC,CAAC","ignoreList":[]}

package/features/GetScheduledAction/abstractions.d.ts

@@ -0,0 +1,26 @@
+import { Result } from "@webiny/feature/api";
+import type { IScheduledAction } from "../../shared/abstractions.js";
+import { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from "../../domain/errors.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * GetScheduledActionUseCase - Retrieve a scheduled action by ID
+ *
+ * Used to check if a schedule exists (for reschedule logic) and to retrieve
+ * schedule details for display/management purposes.
+ *
+ * Returns null value (Result.ok(null)) if schedule not found.
+ */
+export interface IGetScheduledActionErrors {
+    persistence: ScheduledActionPersistenceError;
+    notFound: ScheduledActionNotFoundError;
+}
+type GetScheduledActionError = IGetScheduledActionErrors[keyof IGetScheduledActionErrors];
+export interface IGetScheduledActionUseCase {
+    execute<T extends GenericRecord>(scheduleId: string): Promise<Result<IScheduledAction<T>, GetScheduledActionError>>;
+}
+export declare const GetScheduledActionUseCase: import("@webiny/di").Abstraction<IGetScheduledActionUseCase>;
+export declare namespace GetScheduledActionUseCase {
+    type Interface = IGetScheduledActionUseCase;
+    type Error = GetScheduledActionError;
+}
+export {};

package/features/GetScheduledAction/abstractions.js

@@ -0,0 +1,14 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetScheduledActionUseCase - Retrieve a scheduled action by ID
+ *
+ * Used to check if a schedule exists (for reschedule logic) and to retrieve
+ * schedule details for display/management purposes.
+ *
+ * Returns null value (Result.ok(null)) if schedule not found.
+ */
+
+export const GetScheduledActionUseCase = createAbstraction("GetScheduledActionUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/GetScheduledAction/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetScheduledActionUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { IScheduledAction } from \"~/shared/abstractions.js\";\nimport { ScheduledActionNotFoundError, ScheduledActionPersistenceError } from \"~/domain/errors.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\n/**\n * GetScheduledActionUseCase - Retrieve a scheduled action by ID\n *\n * Used to check if a schedule exists (for reschedule logic) and to retrieve\n * schedule details for display/management purposes.\n *\n * Returns null value (Result.ok(null)) if schedule not found.\n */\n\nexport interface IGetScheduledActionErrors {\n    persistence: ScheduledActionPersistenceError;\n    notFound: ScheduledActionNotFoundError;\n}\n\ntype GetScheduledActionError = IGetScheduledActionErrors[keyof IGetScheduledActionErrors];\n\nexport interface IGetScheduledActionUseCase {\n    execute<T extends GenericRecord>(\n        scheduleId: string\n    ): Promise<Result<IScheduledAction<T>, GetScheduledActionError>>;\n}\n\nexport const GetScheduledActionUseCase = createAbstraction<IGetScheduledActionUseCase>(\n    \"GetScheduledActionUseCase\"\n);\n\nexport namespace GetScheduledActionUseCase {\n    export type Interface = IGetScheduledActionUseCase;\n    export type Error = GetScheduledActionError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAMvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAeA,OAAO,MAAMC,yBAAyB,GAAGD,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}

package/features/GetScheduledAction/feature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GetScheduledAction Feature
+ *
+ * Provides the ability to retrieve a scheduled action by ID.
+ * Used for checking if schedules exist and displaying schedule details.
+ */
+export declare const GetScheduledActionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/GetScheduledAction/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetScheduledActionUseCase } from "./GetScheduledActionUseCase.js";
+
+/**
+ * GetScheduledAction Feature
+ *
+ * Provides the ability to retrieve a scheduled action by ID.
+ * Used for checking if schedules exist and displaying schedule details.
+ */
+export const GetScheduledActionFeature = createFeature({
+  name: "GetScheduledAction",
+  register(container) {
+    container.register(GetScheduledActionUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/GetScheduledAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetScheduledActionUseCase","GetScheduledActionFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetScheduledActionUseCase } from \"./GetScheduledActionUseCase.js\";\n\n/**\n * GetScheduledAction Feature\n *\n * Provides the ability to retrieve a scheduled action by ID.\n * Used for checking if schedules exist and displaying schedule details.\n */\nexport const GetScheduledActionFeature = createFeature({\n    name: \"GetScheduledAction\",\n    register(container) {\n        container.register(GetScheduledActionUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,yBAAyB;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,yBAAyB,GAAGF,aAAa,CAAC;EACnDG,IAAI,EAAE,oBAAoB;EAC1BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,yBAAyB,CAAC;EACjD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/GetScheduledAction/index.d.ts

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

package/features/GetScheduledAction/index.js

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

package/features/GetScheduledAction/index.js.map

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

package/features/ListScheduledActions/ListScheduledActionsUseCase.d.ts

@@ -0,0 +1,27 @@
+import { Result } from "@webiny/feature/api";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+import { IListScheduledActionsParams, IListScheduledActionsResponse, ListScheduledActionsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ScheduledActionModel } from "../../shared/abstractions.js";
+import { CmsSortMapper, CmsWhereMapper } from "@webiny/api-headless-cms";
+import type { GenericRecord } from "@webiny/api/types.js";
+/**
+ * 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
+ */
+declare class ListScheduledActionsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private listEntriesUseCase;
+    private model;
+    private cmsWhereMapper;
+    private cmsSortMapper;
+    constructor(listEntriesUseCase: ListLatestEntriesUseCase.Interface, model: ScheduledActionModel.Interface, cmsWhereMapper: CmsWhereMapper.Interface, cmsSortMapper: CmsSortMapper.Interface);
+    execute<T extends GenericRecord>(params: IListScheduledActionsParams): Promise<Result<IListScheduledActionsResponse<T>, UseCaseAbstraction.Error>>;
+}
+export declare const ListScheduledActionsUseCase: typeof ListScheduledActionsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListScheduledActionsUseCase>;
+};
+export {};