@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/features/contentEntry/DeleteEntryRevision/DeleteEntryRevisionUseCase.js

@@ -0,0 +1,100 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { DeleteEntryRevisionRepository, DeleteEntryRevisionUseCase } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../GetRevisionById/index.js";
+import { GetLatestRevisionByEntryIdIncludingDeletedUseCase } from "../GetLatestRevisionByEntryId/index.js";
+import { GetPreviousRevisionByEntryIdUseCase } from "../GetPreviousRevisionByEntryId/index.js";
+import { DeleteEntryUseCase } from "../DeleteEntry/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { EntryRevisionAfterDeleteEvent, EntryRevisionBeforeDeleteEvent, EntryRevisionDeleteErrorEvent } from "./events.js";
+import { parseIdentifier } from "@webiny/utils";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+class DeleteEntryRevisionUseCaseImpl {
+    constructor(repository, accessControl, getRevisionById, getLatestRevision, getPreviousRevision, deleteEntry, eventPublisher){
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.getRevisionById = getRevisionById;
+        this.getLatestRevision = getLatestRevision;
+        this.getPreviousRevision = getPreviousRevision;
+        this.deleteEntry = deleteEntry;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(model, revisionId) {
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            rwd: "d"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const { id: entryId, version } = parseIdentifier(revisionId);
+        const getRevisionResult = await this.getRevisionById.execute(model, revisionId);
+        if (getRevisionResult.isFail()) return Result.fail(getRevisionResult.error);
+        const entryToDelete = getRevisionResult.value;
+        const canAccessEntry = await this.accessControl.canAccessEntry({
+            model,
+            entry: entryToDelete,
+            rwd: "d"
+        });
+        if (!canAccessEntry) return Result.fail(new EntryNotAuthorizedError());
+        const latestRevisionResult = await this.getLatestRevision.execute(model, {
+            id: entryId
+        });
+        if (latestRevisionResult.isFail()) return Result.fail(latestRevisionResult.error);
+        const latestRevision = latestRevisionResult.value;
+        const latestRevisionId = latestRevision?.id || null;
+        const previousRevisionResult = await this.getPreviousRevision.execute(model, {
+            entryId,
+            version: version
+        });
+        const previousRevision = previousRevisionResult.isFail() ? null : previousRevisionResult.value;
+        if (previousRevisionResult.isFail() && entryToDelete.id === latestRevisionId) return await this.deleteEntry.execute(model, revisionId, {});
+        let latestEntry = null;
+        if (entryToDelete.id === latestRevisionId && previousRevision) latestEntry = previousRevision;
+        try {
+            await this.eventPublisher.publish(new EntryRevisionBeforeDeleteEvent({
+                entry: entryToDelete,
+                model
+            }));
+            const result = await this.repository.execute({
+                model,
+                entry: entryToDelete,
+                latestEntry
+            });
+            if (result.isFail()) {
+                await this.eventPublisher.publish(new EntryRevisionDeleteErrorEvent({
+                    entry: entryToDelete,
+                    model,
+                    error: result.error
+                }));
+                return Result.fail(result.error);
+            }
+            await this.eventPublisher.publish(new EntryRevisionAfterDeleteEvent({
+                entry: entryToDelete,
+                model
+            }));
+            return Result.ok();
+        } catch (error) {
+            await this.eventPublisher.publish(new EntryRevisionDeleteErrorEvent({
+                entry: entryToDelete,
+                model,
+                error: error
+            }));
+            return Result.fail(error);
+        }
+    }
+}
+const DeleteEntryRevisionUseCase_DeleteEntryRevisionUseCase = createImplementation({
+    abstraction: DeleteEntryRevisionUseCase,
+    implementation: DeleteEntryRevisionUseCaseImpl,
+    dependencies: [
+        DeleteEntryRevisionRepository,
+        AccessControl,
+        GetRevisionByIdUseCase,
+        GetLatestRevisionByEntryIdIncludingDeletedUseCase,
+        GetPreviousRevisionByEntryIdUseCase,
+        DeleteEntryUseCase,
+        EventPublisher
+    ]
+});
+export { DeleteEntryRevisionUseCase_DeleteEntryRevisionUseCase as DeleteEntryRevisionUseCase };
+
+//# sourceMappingURL=DeleteEntryRevisionUseCase.js.map

package/features/contentEntry/DeleteEntryRevision/DeleteEntryRevisionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteEntryRevision/DeleteEntryRevisionUseCase.js","sources":["../../../../src/features/contentEntry/DeleteEntryRevision/DeleteEntryRevisionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { DeleteEntryRevisionUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { DeleteEntryRevisionRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { GetRevisionByIdUseCase } from \"~/features/contentEntry/GetRevisionById/index.js\";\nimport { GetLatestRevisionByEntryIdIncludingDeletedUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport { GetPreviousRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetPreviousRevisionByEntryId/index.js\";\nimport { DeleteEntryUseCase } from \"~/features/contentEntry/DeleteEntry/index.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport {\n    EntryRevisionBeforeDeleteEvent,\n    EntryRevisionAfterDeleteEvent,\n    EntryRevisionDeleteErrorEvent\n} from \"./events.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * DeleteEntryRevisionUseCase - Orchestrates deletion of a specific entry revision.\n *\n * Responsibilities:\n * - Parse revision ID to extract entry ID and version\n * - Apply access control\n * - Get the revision to delete\n * - Determine if this is the latest revision\n * - If latest and no previous revision exists, perform full entry delete\n * - If latest and previous exists, set previous as new latest\n * - Publish domain events\n * - Delegate to repository for storage operations\n */\nclass DeleteEntryRevisionUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: DeleteEntryRevisionRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private getLatestRevision: GetLatestRevisionByEntryIdIncludingDeletedUseCase.Interface,\n        private getPreviousRevision: GetPreviousRevisionByEntryIdUseCase.Interface,\n        private deleteEntry: DeleteEntryUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(\n        model: CmsModel,\n        revisionId: string\n    ): Promise<Result<void, UseCaseAbstraction.Error>> {\n        // Check access control\n        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"d\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        const { id: entryId, version } = parseIdentifier(revisionId);\n\n        // Get the revision to delete\n        const getRevisionResult = await this.getRevisionById.execute(model, revisionId);\n        if (getRevisionResult.isFail()) {\n            return Result.fail(getRevisionResult.error);\n        }\n\n        const entryToDelete = getRevisionResult.value;\n\n        // Check access control on the specific entry\n        const canAccessEntry = await this.accessControl.canAccessEntry({\n            model,\n            entry: entryToDelete,\n            rwd: \"d\"\n        });\n\n        if (!canAccessEntry) {\n            return Result.fail(new EntryNotAuthorizedError());\n        }\n\n        // Get the latest revision\n        const latestRevisionResult = await this.getLatestRevision.execute(model, { id: entryId });\n        if (latestRevisionResult.isFail()) {\n            return Result.fail(latestRevisionResult.error);\n        }\n\n        const latestRevision = latestRevisionResult.value;\n        const latestRevisionId = latestRevision?.id || null;\n\n        // Get the previous revision\n        const previousRevisionResult = await this.getPreviousRevision.execute(model, {\n            entryId,\n            version: version as number\n        });\n\n        // If targeted record is the latest entry record and there is no previous revision,\n        // delete the entire entry.\n        const previousRevision = previousRevisionResult.isFail()\n            ? null\n            : previousRevisionResult.value;\n        if (previousRevisionResult.isFail() && entryToDelete.id === latestRevisionId) {\n            return await this.deleteEntry.execute(model, revisionId, {});\n        }\n\n        // Determine the entry to set as latest (if deleting current latest)\n        let latestEntry = null;\n        if (entryToDelete.id === latestRevisionId && previousRevision) {\n            latestEntry = previousRevision;\n        }\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryRevisionBeforeDeleteEvent({\n                    entry: entryToDelete,\n                    model\n                })\n            );\n\n            // Delegate to repository\n            const result = await this.repository.execute({\n                model,\n                entry: entryToDelete,\n                latestEntry\n            });\n\n            if (result.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryRevisionDeleteErrorEvent({\n                        entry: entryToDelete,\n                        model,\n                        error: result.error\n                    })\n                );\n                return Result.fail(result.error);\n            }\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryRevisionAfterDeleteEvent({\n                    entry: entryToDelete,\n                    model\n                })\n            );\n\n            return Result.ok();\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryRevisionDeleteErrorEvent({\n                    entry: entryToDelete,\n                    model,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const DeleteEntryRevisionUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: DeleteEntryRevisionUseCaseImpl,\n    dependencies: [\n        DeleteEntryRevisionRepository,\n        AccessControl,\n        GetRevisionByIdUseCase,\n        GetLatestRevisionByEntryIdIncludingDeletedUseCase,\n        GetPreviousRevisionByEntryIdUseCase,\n        DeleteEntryUseCase,\n        EventPublisher\n    ]\n});\n"],"names":["DeleteEntryRevisionUseCaseImpl","repository","accessControl","getRevisionById","getLatestRevision","getPreviousRevision","deleteEntry","eventPublisher","model","revisionId","canAccess","Result","EntryNotAuthorizedError","entryId","version","parseIdentifier","getRevisionResult","entryToDelete","canAccessEntry","latestRevisionResult","latestRevision","latestRevisionId","previousRevisionResult","previousRevision","latestEntry","EntryRevisionBeforeDeleteEvent","result","EntryRevisionDeleteErrorEvent","EntryRevisionAfterDeleteEvent","error","DeleteEntryRevisionUseCase","createImplementation","UseCaseAbstraction","DeleteEntryRevisionRepository","AccessControl","GetRevisionByIdUseCase","GetLatestRevisionByEntryIdIncludingDeletedUseCase","GetPreviousRevisionByEntryIdUseCase","DeleteEntryUseCase","EventPublisher"],"mappings":";;;;;;;;;;;AAgCA,MAAMA;IACF,YACYC,UAAmD,EACnDC,aAAsC,EACtCC,eAAiD,EACjDC,iBAA8E,EAC9EC,mBAAkE,EAClEC,WAAyC,EACzCC,cAAwC,CAClD;aAPUN,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,iBAAiB,GAAjBA;aACAC,mBAAmB,GAAnBA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAAe,EACfC,UAAkB,EAC6B;QAE/C,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEF;YAAO,KAAK;QAAI;QAC5E,IAAI,CAACE,WACD,OAAOC,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAGzD,MAAM,EAAE,IAAIK,OAAO,EAAEC,OAAO,EAAE,GAAGC,gBAAgBN;QAGjD,MAAMO,oBAAoB,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACR,OAAOC;QACpE,IAAIO,kBAAkB,MAAM,IACxB,OAAOL,OAAO,IAAI,CAACK,kBAAkB,KAAK;QAG9C,MAAMC,gBAAgBD,kBAAkB,KAAK;QAG7C,MAAME,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAC3DV;YACA,OAAOS;YACP,KAAK;QACT;QAEA,IAAI,CAACC,gBACD,OAAOP,OAAO,IAAI,CAAC,IAAIC;QAI3B,MAAMO,uBAAuB,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACX,OAAO;YAAE,IAAIK;QAAQ;QACvF,IAAIM,qBAAqB,MAAM,IAC3B,OAAOR,OAAO,IAAI,CAACQ,qBAAqB,KAAK;QAGjD,MAAMC,iBAAiBD,qBAAqB,KAAK;QACjD,MAAME,mBAAmBD,gBAAgB,MAAM;QAG/C,MAAME,yBAAyB,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAACd,OAAO;YACzEK;YACA,SAASC;QACb;QAIA,MAAMS,mBAAmBD,uBAAuB,MAAM,KAChD,OACAA,uBAAuB,KAAK;QAClC,IAAIA,uBAAuB,MAAM,MAAML,cAAc,EAAE,KAAKI,kBACxD,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACb,OAAOC,YAAY,CAAC;QAI9D,IAAIe,cAAc;QAClB,IAAIP,cAAc,EAAE,KAAKI,oBAAoBE,kBACzCC,cAAcD;QAGlB,IAAI;YAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,+BAA+B;gBAC/B,OAAOR;gBACPT;YACJ;YAIJ,MAAMkB,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;gBACzClB;gBACA,OAAOS;gBACPO;YACJ;YAEA,IAAIE,OAAO,MAAM,IAAI;gBACjB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;oBAC9B,OAAOV;oBACPT;oBACA,OAAOkB,OAAO,KAAK;gBACvB;gBAEJ,OAAOf,OAAO,IAAI,CAACe,OAAO,KAAK;YACnC;YAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,8BAA8B;gBAC9B,OAAOX;gBACPT;YACJ;YAGJ,OAAOG,OAAO,EAAE;QACpB,EAAE,OAAOkB,OAAO;YACZ,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIF,8BAA8B;gBAC9B,OAAOV;gBACPT;gBACA,OAAOqB;YACX;YAEJ,OAAOlB,OAAO,IAAI,CAACkB;QACvB;IACJ;AACJ;AAEO,MAAMC,wDAA6BC,qBAAqB;IAC3D,aAAaC;IACb,gBAAgBhC;IAChB,cAAc;QACViC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/contentEntry/DeleteEntryRevision/abstractions.d.ts

@@ -0,0 +1,65 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryNotFoundError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * DeleteEntryRevision Use Case - Deletes a specific revision of an entry.
+ * Handles special cases like deleting the latest revision.
+ */
+export interface IDeleteEntryRevisionUseCase {
+    execute(model: CmsModel, revisionId: string): Promise<Result<void, UseCaseError>>;
+}
+export interface IDeleteEntryRevisionUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    notFound: EntryNotFoundError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IDeleteEntryRevisionUseCaseErrors[keyof IDeleteEntryRevisionUseCaseErrors];
+/** Delete a specific entry revision. */
+export declare const DeleteEntryRevisionUseCase: import("@webiny/di").Abstraction<IDeleteEntryRevisionUseCase>;
+export declare namespace DeleteEntryRevisionUseCase {
+    type Interface = IDeleteEntryRevisionUseCase;
+    type Error = UseCaseError;
+    type Return = Promise<Result<void, UseCaseError>>;
+}
+/**
+ * Payload for before delete event
+ */
+export interface EntryRevisionBeforeDeletePayload {
+    entry: CmsEntry;
+    model: CmsModel;
+}
+/**
+ * Payload for after delete event
+ */
+export interface EntryRevisionAfterDeletePayload {
+    entry: CmsEntry;
+    model: CmsModel;
+}
+/**
+ * Payload for delete error event
+ */
+export interface EntryRevisionDeleteErrorPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * DeleteEntryRevisionRepository - Handles storage operations for deleting entry revisions.
+ */
+export interface IDeleteEntryRevisionRepository {
+    execute(params: {
+        model: CmsModel;
+        entry: CmsEntry;
+        latestEntry: CmsEntry | null;
+    }): Promise<Result<void, RepositoryError>>;
+}
+export interface IDeleteEntryRevisionRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IDeleteEntryRevisionRepositoryErrors[keyof IDeleteEntryRevisionRepositoryErrors];
+export declare const DeleteEntryRevisionRepository: import("@webiny/di").Abstraction<IDeleteEntryRevisionRepository>;
+export declare namespace DeleteEntryRevisionRepository {
+    type Interface = IDeleteEntryRevisionRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/DeleteEntryRevision/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const DeleteEntryRevisionUseCase = createAbstraction("DeleteEntryRevisionUseCase");
+const DeleteEntryRevisionRepository = createAbstraction("DeleteEntryRevisionRepository");
+export { DeleteEntryRevisionRepository, DeleteEntryRevisionUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentEntry/DeleteEntryRevision/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteEntryRevision/abstractions.js","sources":["../../../../src/features/contentEntry/DeleteEntryRevision/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsModel } from \"~/types/index.js\";\nimport type {\n    EntryNotAuthorizedError,\n    EntryNotFoundError,\n    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * DeleteEntryRevision Use Case - Deletes a specific revision of an entry.\n * Handles special cases like deleting the latest revision.\n */\nexport interface IDeleteEntryRevisionUseCase {\n    execute(model: CmsModel, revisionId: string): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IDeleteEntryRevisionUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IDeleteEntryRevisionUseCaseErrors[keyof IDeleteEntryRevisionUseCaseErrors];\n\n/** Delete a specific entry revision. */\nexport const DeleteEntryRevisionUseCase = createAbstraction<IDeleteEntryRevisionUseCase>(\n    \"DeleteEntryRevisionUseCase\"\n);\n\nexport namespace DeleteEntryRevisionUseCase {\n    export type Interface = IDeleteEntryRevisionUseCase;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<void, UseCaseError>>;\n}\n\n/**\n * Payload for before delete event\n */\nexport interface EntryRevisionBeforeDeletePayload {\n    entry: CmsEntry;\n    model: CmsModel;\n}\n\n/**\n * Payload for after delete event\n */\nexport interface EntryRevisionAfterDeletePayload {\n    entry: CmsEntry;\n    model: CmsModel;\n}\n\n/**\n * Payload for delete error event\n */\nexport interface EntryRevisionDeleteErrorPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * DeleteEntryRevisionRepository - Handles storage operations for deleting entry revisions.\n */\nexport interface IDeleteEntryRevisionRepository {\n    execute(params: {\n        model: CmsModel;\n        entry: CmsEntry;\n        latestEntry: CmsEntry | null;\n    }): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IDeleteEntryRevisionRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError =\n    IDeleteEntryRevisionRepositoryErrors[keyof IDeleteEntryRevisionRepositoryErrors];\n\nexport const DeleteEntryRevisionRepository = createAbstraction<IDeleteEntryRevisionRepository>(\n    \"DeleteEntryRevisionRepository\"\n);\n\nexport namespace DeleteEntryRevisionRepository {\n    export type Interface = IDeleteEntryRevisionRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["DeleteEntryRevisionUseCase","createAbstraction","DeleteEntryRevisionRepository"],"mappings":";AAyBO,MAAMA,6BAA6BC,kBACtC;AAqDG,MAAMC,gCAAgCD,kBACzC"}

package/features/contentEntry/DeleteEntryRevision/events.d.ts

@@ -0,0 +1,41 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { EntryRevisionAfterDeletePayload, EntryRevisionBeforeDeletePayload, EntryRevisionDeleteErrorPayload } from "./abstractions.js";
+/**
+ * Before delete revision event
+ */
+export declare class EntryRevisionBeforeDeleteEvent extends DomainEvent<EntryRevisionBeforeDeletePayload> {
+    eventType: "Cms/Entry/RevisionBeforeDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryRevisionBeforeDeleteEvent>>;
+}
+/** Hook into revision lifecycle before a revision is deleted. */
+export declare const EntryRevisionBeforeDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryRevisionBeforeDeleteEvent>>;
+export declare namespace EntryRevisionBeforeDeleteEventHandler {
+    type Interface = IEventHandler<EntryRevisionBeforeDeleteEvent>;
+    type Event = EntryRevisionBeforeDeleteEvent;
+}
+/**
+ * After delete revision event
+ */
+export declare class EntryRevisionAfterDeleteEvent extends DomainEvent<EntryRevisionAfterDeletePayload> {
+    eventType: "Cms/Entry/RevisionAfterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryRevisionAfterDeleteEvent>>;
+}
+/** Hook into revision lifecycle after a revision is deleted. */
+export declare const EntryRevisionAfterDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryRevisionAfterDeleteEvent>>;
+export declare namespace EntryRevisionAfterDeleteEventHandler {
+    type Interface = IEventHandler<EntryRevisionAfterDeleteEvent>;
+    type Event = EntryRevisionAfterDeleteEvent;
+}
+/**
+ * Delete revision error event
+ */
+export declare class EntryRevisionDeleteErrorEvent extends DomainEvent<EntryRevisionDeleteErrorPayload> {
+    eventType: "Cms/Entry/RevisionDeleteError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryRevisionDeleteErrorEvent>>;
+}
+export declare const EntryRevisionDeleteErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryRevisionDeleteErrorEvent>>;
+export declare namespace EntryRevisionDeleteErrorEventHandler {
+    type Interface = IEventHandler<EntryRevisionDeleteErrorEvent>;
+    type Event = EntryRevisionDeleteErrorEvent;
+}

package/features/contentEntry/DeleteEntryRevision/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class EntryRevisionBeforeDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryRevisionBeforeDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/RevisionBeforeDelete";
+    }
+}
+const EntryRevisionBeforeDeleteEventHandler = createAbstraction("EntryRevisionBeforeDeleteEventHandler");
+class EntryRevisionAfterDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryRevisionAfterDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/RevisionAfterDelete";
+    }
+}
+const EntryRevisionAfterDeleteEventHandler = createAbstraction("EntryRevisionAfterDeleteEventHandler");
+class EntryRevisionDeleteErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryRevisionDeleteErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/RevisionDeleteError";
+    }
+}
+const EntryRevisionDeleteErrorEventHandler = createAbstraction("EntryRevisionDeleteErrorEventHandler");
+export { EntryRevisionAfterDeleteEvent, EntryRevisionAfterDeleteEventHandler, EntryRevisionBeforeDeleteEvent, EntryRevisionBeforeDeleteEventHandler, EntryRevisionDeleteErrorEvent, EntryRevisionDeleteErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/contentEntry/DeleteEntryRevision/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteEntryRevision/events.js","sources":["../../../../src/features/contentEntry/DeleteEntryRevision/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type {\n    EntryRevisionAfterDeletePayload,\n    EntryRevisionBeforeDeletePayload,\n    EntryRevisionDeleteErrorPayload\n} from \"./abstractions.js\";\n\n/**\n * Before delete revision event\n */\nexport class EntryRevisionBeforeDeleteEvent extends DomainEvent<EntryRevisionBeforeDeletePayload> {\n    eventType = \"Cms/Entry/RevisionBeforeDelete\" as const;\n\n    getHandlerAbstraction() {\n        return EntryRevisionBeforeDeleteEventHandler;\n    }\n}\n\n/** Hook into revision lifecycle before a revision is deleted. */\nexport const EntryRevisionBeforeDeleteEventHandler = createAbstraction<\n    IEventHandler<EntryRevisionBeforeDeleteEvent>\n>(\"EntryRevisionBeforeDeleteEventHandler\");\n\nexport namespace EntryRevisionBeforeDeleteEventHandler {\n    export type Interface = IEventHandler<EntryRevisionBeforeDeleteEvent>;\n    export type Event = EntryRevisionBeforeDeleteEvent;\n}\n\n/**\n * After delete revision event\n */\nexport class EntryRevisionAfterDeleteEvent extends DomainEvent<EntryRevisionAfterDeletePayload> {\n    eventType = \"Cms/Entry/RevisionAfterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return EntryRevisionAfterDeleteEventHandler;\n    }\n}\n\n/** Hook into revision lifecycle after a revision is deleted. */\nexport const EntryRevisionAfterDeleteEventHandler = createAbstraction<\n    IEventHandler<EntryRevisionAfterDeleteEvent>\n>(\"EntryRevisionAfterDeleteEventHandler\");\n\nexport namespace EntryRevisionAfterDeleteEventHandler {\n    export type Interface = IEventHandler<EntryRevisionAfterDeleteEvent>;\n    export type Event = EntryRevisionAfterDeleteEvent;\n}\n\n/**\n * Delete revision error event\n */\nexport class EntryRevisionDeleteErrorEvent extends DomainEvent<EntryRevisionDeleteErrorPayload> {\n    eventType = \"Cms/Entry/RevisionDeleteError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryRevisionDeleteErrorEventHandler;\n    }\n}\n\nexport const EntryRevisionDeleteErrorEventHandler = createAbstraction<\n    IEventHandler<EntryRevisionDeleteErrorEvent>\n>(\"EntryRevisionDeleteErrorEventHandler\");\n\nexport namespace EntryRevisionDeleteErrorEventHandler {\n    export type Interface = IEventHandler<EntryRevisionDeleteErrorEvent>;\n    export type Event = EntryRevisionDeleteErrorEvent;\n}\n"],"names":["EntryRevisionBeforeDeleteEvent","DomainEvent","EntryRevisionBeforeDeleteEventHandler","createAbstraction","EntryRevisionAfterDeleteEvent","EntryRevisionAfterDeleteEventHandler","EntryRevisionDeleteErrorEvent","EntryRevisionDeleteErrorEventHandler"],"mappings":";;AAYO,MAAMA,uCAAuCC;IAGhD,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,wCAAwCC,kBAEnD;AAUK,MAAMC,sCAAsCH;IAG/C,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,uCAAuCF,kBAElD;AAUK,MAAMG,sCAAsCL;IAG/C,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,uCAAuCJ,kBAElD"}

package/features/contentEntry/DeleteEntryRevision/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const DeleteEntryRevisionFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentEntry/DeleteEntryRevision/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteEntryRevisionUseCase } from "./DeleteEntryRevisionUseCase.js";
+import { DeleteEntryRevisionRepository } from "./DeleteEntryRevisionRepository.js";
+const DeleteEntryRevisionFeature = createFeature({
+    name: "DeleteEntryRevision",
+    register (container) {
+        container.register(DeleteEntryRevisionRepository).inSingletonScope();
+        container.register(DeleteEntryRevisionUseCase);
+    }
+});
+export { DeleteEntryRevisionFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/DeleteEntryRevision/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteEntryRevision/feature.js","sources":["../../../../src/features/contentEntry/DeleteEntryRevision/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteEntryRevisionUseCase } from \"./DeleteEntryRevisionUseCase.js\";\nimport { DeleteEntryRevisionRepository } from \"./DeleteEntryRevisionRepository.js\";\n\nexport const DeleteEntryRevisionFeature = createFeature({\n    name: \"DeleteEntryRevision\",\n    register(container) {\n        // Register repository (singleton scope)\n        container.register(DeleteEntryRevisionRepository).inSingletonScope();\n\n        // Register use case (transient scope)\n        container.register(DeleteEntryRevisionUseCase);\n    }\n});\n"],"names":["DeleteEntryRevisionFeature","createFeature","container","DeleteEntryRevisionRepository","DeleteEntryRevisionUseCase"],"mappings":";;;AAIO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC,+BAA+B,gBAAgB;QAGlED,UAAU,QAAQ,CAACE;IACvB;AACJ"}

package/features/contentEntry/DeleteEntryRevision/index.d.ts

@@ -0,0 +1,2 @@
+export { DeleteEntryRevisionUseCase, DeleteEntryRevisionRepository } from "./abstractions.js";
+export { EntryRevisionBeforeDeleteEventHandler, EntryRevisionAfterDeleteEventHandler } from "./events.js";

package/features/contentEntry/DeleteEntryRevision/index.js

@@ -0,0 +1,2 @@
+export { DeleteEntryRevisionRepository, DeleteEntryRevisionUseCase } from "./abstractions.js";
+export { EntryRevisionAfterDeleteEventHandler, EntryRevisionBeforeDeleteEventHandler } from "./events.js";

package/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesRepository.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteMultipleEntriesRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.
+ *
+ * Responsibilities:
+ * - Call storage operation to delete multiple entries
+ * - Handle storage errors
+ */
+declare class DeleteMultipleEntriesRepositoryImpl implements RepositoryAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: StorageOperations.Interface);
+    execute(model: CmsModel, entryIds: string[]): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const DeleteMultipleEntriesRepository: import("@webiny/di").Implementation<typeof DeleteMultipleEntriesRepositoryImpl>;
+export {};

package/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesRepository.js

@@ -0,0 +1,29 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { DeleteMultipleEntriesRepository } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+class DeleteMultipleEntriesRepositoryImpl {
+    constructor(storageOperations){
+        this.storageOperations = storageOperations;
+    }
+    async execute(model, entryIds) {
+        try {
+            await this.storageOperations.entries.deleteMultipleEntries(model, {
+                entries: entryIds
+            });
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(new EntryPersistenceError(error));
+        }
+    }
+}
+const DeleteMultipleEntriesRepository_DeleteMultipleEntriesRepository = createImplementation({
+    abstraction: DeleteMultipleEntriesRepository,
+    implementation: DeleteMultipleEntriesRepositoryImpl,
+    dependencies: [
+        StorageOperations
+    ]
+});
+export { DeleteMultipleEntriesRepository_DeleteMultipleEntriesRepository as DeleteMultipleEntriesRepository };
+
+//# sourceMappingURL=DeleteMultipleEntriesRepository.js.map

package/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesRepository.js","sources":["../../../../src/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { DeleteMultipleEntriesRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.\n *\n * Responsibilities:\n * - Call storage operation to delete multiple entries\n * - Handle storage errors\n */\nclass DeleteMultipleEntriesRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(private storageOperations: StorageOperations.Interface) {}\n\n    async execute(\n        model: CmsModel,\n        entryIds: string[]\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            await this.storageOperations.entries.deleteMultipleEntries(model, {\n                entries: entryIds\n            });\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const DeleteMultipleEntriesRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: DeleteMultipleEntriesRepositoryImpl,\n    dependencies: [StorageOperations]\n});\n"],"names":["DeleteMultipleEntriesRepositoryImpl","storageOperations","model","entryIds","Result","error","EntryPersistenceError","DeleteMultipleEntriesRepository","createImplementation","RepositoryAbstraction","StorageOperations"],"mappings":";;;;AAcA,MAAMA;IACF,YAA2BC,iBAA8C,CAAE;aAAhDA,iBAAiB,GAAjBA;IAAiD;IAE5E,MAAM,QACFC,KAAe,EACfC,QAAkB,EACgC;QAClD,IAAI;YACA,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,qBAAqB,CAACD,OAAO;gBAC9D,SAASC;YACb;YACA,OAAOC,OAAO,EAAE;QACpB,EAAE,OAAOC,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,sBAAsBD;QACjD;IACJ;AACJ;AAEO,MAAME,kEAAkCC,qBAAqB;IAChE,aAAaC;IACb,gBAAgBT;IAChB,cAAc;QAACU;KAAkB;AACrC"}

package/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesUseCase.d.ts

@@ -0,0 +1,33 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DeleteMultipleEntriesUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteMultipleEntriesRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { ListEntriesUseCase } from "../../../features/contentEntry/ListEntries/abstractions.js";
+import type { CmsModel } from "../../../types/index.js";
+/**
+ * DeleteMultipleEntriesUseCase - Orchestrates deleting multiple entries.
+ *
+ * Responsibilities:
+ * - Validate max entries limit (50)
+ * - Parse entry IDs to unique entry IDs
+ * - Apply access control
+ * - Fetch entries using ListEntries use case
+ * - Filter entries by access control
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+declare class DeleteMultipleEntriesUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private listEntries;
+    private eventPublisher;
+    constructor(repository: DeleteMultipleEntriesRepository.Interface, accessControl: AccessControl.Interface, listEntries: ListEntriesUseCase.Interface, eventPublisher: EventPublisher.Interface);
+    execute(model: CmsModel, params: {
+        entries: string[];
+    }): Promise<Result<Array<{
+        id: string;
+    }>, UseCaseAbstraction.Error>>;
+}
+export declare const DeleteMultipleEntriesUseCase: import("@webiny/di").Implementation<typeof DeleteMultipleEntriesUseCaseImpl>;
+export {};

package/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesUseCase.js

@@ -0,0 +1,96 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DeleteMultipleEntriesRepository, DeleteMultipleEntriesUseCase } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { ListEntriesUseCase } from "../ListEntries/abstractions.js";
+import { EntryAfterDeleteMultipleEvent, EntryBeforeDeleteMultipleEvent, EntryDeleteMultipleErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { parseIdentifier } from "@webiny/utils";
+import _webiny_error from "@webiny/error";
+import { filterAsync } from "../../../utils/filterAsync.js";
+class DeleteMultipleEntriesUseCaseImpl {
+    constructor(repository, accessControl, listEntries, eventPublisher){
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.listEntries = listEntries;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(model, params) {
+        const { entries: input } = params;
+        const maxDeletableEntries = 50;
+        const entryIdList = new Set();
+        for (const id of input){
+            const { id: entryId } = parseIdentifier(id);
+            entryIdList.add(entryId);
+        }
+        const ids = Array.from(entryIdList);
+        if (ids.length > maxDeletableEntries) return Result.fail(new _webiny_error("Cannot delete more than 50 entries at once.", "DELETE_ENTRIES_MAX", {
+            entries: ids
+        }));
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            rwd: "d"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const listResult = await this.listEntries.execute(model, {
+            where: {
+                latest: true,
+                entryId_in: ids
+            },
+            limit: maxDeletableEntries + 1
+        });
+        if (listResult.isFail()) return Result.fail(listResult.error);
+        const { entries } = listResult.value;
+        const accessibleEntries = await filterAsync(entries, async (entry)=>this.accessControl.canAccessEntry({
+                model,
+                entry
+            }));
+        const items = accessibleEntries.map((entry)=>entry.id);
+        try {
+            await this.eventPublisher.publish(new EntryBeforeDeleteMultipleEvent({
+                entries,
+                ids,
+                model
+            }));
+            const result = await this.repository.execute(model, items);
+            if (result.isFail()) {
+                await this.eventPublisher.publish(new EntryDeleteMultipleErrorEvent({
+                    entries,
+                    ids,
+                    model,
+                    error: result.error
+                }));
+                return Result.fail(result.error);
+            }
+            await this.eventPublisher.publish(new EntryAfterDeleteMultipleEvent({
+                entries,
+                ids,
+                model
+            }));
+            return Result.ok(items.map((id)=>({
+                    id
+                })));
+        } catch (error) {
+            await this.eventPublisher.publish(new EntryDeleteMultipleErrorEvent({
+                entries,
+                ids,
+                model,
+                error: error
+            }));
+            return Result.fail(error);
+        }
+    }
+}
+const DeleteMultipleEntriesUseCase_DeleteMultipleEntriesUseCase = createImplementation({
+    abstraction: DeleteMultipleEntriesUseCase,
+    implementation: DeleteMultipleEntriesUseCaseImpl,
+    dependencies: [
+        DeleteMultipleEntriesRepository,
+        AccessControl,
+        ListEntriesUseCase,
+        EventPublisher
+    ]
+});
+export { DeleteMultipleEntriesUseCase_DeleteMultipleEntriesUseCase as DeleteMultipleEntriesUseCase };
+
+//# sourceMappingURL=DeleteMultipleEntriesUseCase.js.map

package/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesUseCase.js","sources":["../../../../src/features/contentEntry/DeleteMultipleEntries/DeleteMultipleEntriesUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DeleteMultipleEntriesUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { DeleteMultipleEntriesRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { ListEntriesUseCase } from \"~/features/contentEntry/ListEntries/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport {\n    EntryBeforeDeleteMultipleEvent,\n    EntryAfterDeleteMultipleEvent,\n    EntryDeleteMultipleErrorEvent\n} from \"./events.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport WebinyError from \"@webiny/error\";\nimport { filterAsync } from \"~/utils/filterAsync.js\";\n\n/**\n * DeleteMultipleEntriesUseCase - Orchestrates deleting multiple entries.\n *\n * Responsibilities:\n * - Validate max entries limit (50)\n * - Parse entry IDs to unique entry IDs\n * - Apply access control\n * - Fetch entries using ListEntries use case\n * - Filter entries by access control\n * - Publish domain events\n * - Delegate to repository for storage operations\n */\nclass DeleteMultipleEntriesUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: DeleteMultipleEntriesRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private listEntries: ListEntriesUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(\n        model: CmsModel,\n        params: { entries: string[] }\n    ): Promise<Result<Array<{ id: string }>, UseCaseAbstraction.Error>> {\n        const { entries: input } = params;\n        const maxDeletableEntries = 50;\n\n        // Parse entry IDs to unique entry IDs\n        const entryIdList = new Set<string>();\n        for (const id of input) {\n            const { id: entryId } = parseIdentifier(id);\n            entryIdList.add(entryId);\n        }\n        const ids = Array.from(entryIdList);\n\n        // Validate max entries limit\n        if (ids.length > maxDeletableEntries) {\n            return Result.fail(\n                new WebinyError(\n                    \"Cannot delete more than 50 entries at once.\",\n                    \"DELETE_ENTRIES_MAX\",\n                    {\n                        entries: ids\n                    }\n                ) as any\n            );\n        }\n\n        // Check access control\n        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"d\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Fetch entries using ListEntries use case\n        const listResult = await this.listEntries.execute(model, {\n            where: {\n                latest: true,\n                entryId_in: ids\n            },\n            limit: maxDeletableEntries + 1\n        });\n\n        if (listResult.isFail()) {\n            return Result.fail(listResult.error);\n        }\n\n        const { entries } = listResult.value;\n\n        // Filter entries by access control (only delete entries user can access)\n        const accessibleEntries = await filterAsync(entries, async entry => {\n            return this.accessControl.canAccessEntry({ model, entry });\n        });\n\n        const items = accessibleEntries.map(entry => entry.id);\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryBeforeDeleteMultipleEvent({\n                    entries,\n                    ids,\n                    model\n                })\n            );\n\n            // Delegate to repository\n            const result = await this.repository.execute(model, items);\n\n            if (result.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryDeleteMultipleErrorEvent({\n                        entries,\n                        ids,\n                        model,\n                        error: result.error\n                    })\n                );\n                return Result.fail(result.error);\n            }\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterDeleteMultipleEvent({\n                    entries,\n                    ids,\n                    model\n                })\n            );\n\n            return Result.ok(\n                items.map(id => {\n                    return { id };\n                })\n            );\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryDeleteMultipleErrorEvent({\n                    entries,\n                    ids,\n                    model,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const DeleteMultipleEntriesUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: DeleteMultipleEntriesUseCaseImpl,\n    dependencies: [\n        DeleteMultipleEntriesRepository,\n        AccessControl,\n        ListEntriesUseCase,\n        EventPublisher\n    ]\n});\n"],"names":["DeleteMultipleEntriesUseCaseImpl","repository","accessControl","listEntries","eventPublisher","model","params","input","maxDeletableEntries","entryIdList","Set","id","entryId","parseIdentifier","ids","Array","Result","WebinyError","canAccess","EntryNotAuthorizedError","listResult","entries","accessibleEntries","filterAsync","entry","items","EntryBeforeDeleteMultipleEvent","result","EntryDeleteMultipleErrorEvent","EntryAfterDeleteMultipleEvent","error","DeleteMultipleEntriesUseCase","createImplementation","UseCaseAbstraction","DeleteMultipleEntriesRepository","AccessControl","ListEntriesUseCase","EventPublisher"],"mappings":";;;;;;;;;;AA8BA,MAAMA;IACF,YACYC,UAAqD,EACrDC,aAAsC,EACtCC,WAAyC,EACzCC,cAAwC,CAClD;aAJUH,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAAe,EACfC,MAA6B,EACmC;QAChE,MAAM,EAAE,SAASC,KAAK,EAAE,GAAGD;QAC3B,MAAME,sBAAsB;QAG5B,MAAMC,cAAc,IAAIC;QACxB,KAAK,MAAMC,MAAMJ,MAAO;YACpB,MAAM,EAAE,IAAIK,OAAO,EAAE,GAAGC,gBAAgBF;YACxCF,YAAY,GAAG,CAACG;QACpB;QACA,MAAME,MAAMC,MAAM,IAAI,CAACN;QAGvB,IAAIK,IAAI,MAAM,GAAGN,qBACb,OAAOQ,OAAO,IAAI,CACd,IAAIC,cACA,+CACA,sBACA;YACI,SAASH;QACb;QAMZ,MAAMI,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEb;YAAO,KAAK;QAAI;QAC5E,IAAI,CAACa,WACD,OAAOF,OAAO,IAAI,CAACG,wBAAwB,SAAS,CAACd;QAIzD,MAAMe,aAAa,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACf,OAAO;YACrD,OAAO;gBACH,QAAQ;gBACR,YAAYS;YAChB;YACA,OAAON,sBAAsB;QACjC;QAEA,IAAIY,WAAW,MAAM,IACjB,OAAOJ,OAAO,IAAI,CAACI,WAAW,KAAK;QAGvC,MAAM,EAAEC,OAAO,EAAE,GAAGD,WAAW,KAAK;QAGpC,MAAME,oBAAoB,MAAMC,YAAYF,SAAS,OAAMG,QAChD,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;gBAAEnB;gBAAOmB;YAAM;QAG5D,MAAMC,QAAQH,kBAAkB,GAAG,CAACE,CAAAA,QAASA,MAAM,EAAE;QAErD,IAAI;YAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,+BAA+B;gBAC/BL;gBACAP;gBACAT;YACJ;YAIJ,MAAMsB,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACtB,OAAOoB;YAEpD,IAAIE,OAAO,MAAM,IAAI;gBACjB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;oBAC9BP;oBACAP;oBACAT;oBACA,OAAOsB,OAAO,KAAK;gBACvB;gBAEJ,OAAOX,OAAO,IAAI,CAACW,OAAO,KAAK;YACnC;YAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,8BAA8B;gBAC9BR;gBACAP;gBACAT;YACJ;YAGJ,OAAOW,OAAO,EAAE,CACZS,MAAM,GAAG,CAACd,CAAAA,KACC;oBAAEA;gBAAG;QAGxB,EAAE,OAAOmB,OAAO;YACZ,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIF,8BAA8B;gBAC9BP;gBACAP;gBACAT;gBACA,OAAOyB;YACX;YAEJ,OAAOd,OAAO,IAAI,CAACc;QACvB;IACJ;AACJ;AAEO,MAAMC,4DAA+BC,qBAAqB;IAC7D,aAAaC;IACb,gBAAgBjC;IAChB,cAAc;QACVkC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/contentEntry/DeleteMultipleEntries/abstractions.d.ts

@@ -0,0 +1,69 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * DeleteMultipleEntries Use Case - Deletes multiple entries at once.
+ */
+export interface IDeleteMultipleEntriesUseCaseResultItem {
+    id: string;
+}
+export interface IDeleteMultipleEntriesUseCaseParams {
+    entries: string[];
+}
+export interface IDeleteMultipleEntriesUseCase {
+    execute(model: CmsModel, params: IDeleteMultipleEntriesUseCaseParams): Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;
+}
+export interface IDeleteMultipleEntriesUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IDeleteMultipleEntriesUseCaseErrors[keyof IDeleteMultipleEntriesUseCaseErrors];
+/** Delete multiple content entries in batch. */
+export declare const DeleteMultipleEntriesUseCase: import("@webiny/di").Abstraction<IDeleteMultipleEntriesUseCase>;
+export declare namespace DeleteMultipleEntriesUseCase {
+    type Interface = IDeleteMultipleEntriesUseCase;
+    type Params = IDeleteMultipleEntriesUseCaseParams;
+    type Error = UseCaseError;
+    type Return = Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;
+}
+/**
+ * Payload for before delete multiple event
+ */
+export interface EntryBeforeDeleteMultipleEventPayload {
+    entries: CmsEntry[];
+    ids: string[];
+    model: CmsModel;
+}
+/**
+ * Payload for after delete multiple event
+ */
+export interface EntryAfterDeleteMultipleEventPayload {
+    entries: CmsEntry[];
+    ids: string[];
+    model: CmsModel;
+}
+/**
+ * Payload for delete multiple error event
+ */
+export interface EntryDeleteMultipleErrorEventPayload {
+    entries: CmsEntry[];
+    ids: string[];
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.
+ */
+export interface IDeleteMultipleEntriesRepository {
+    execute(model: CmsModel, entryIds: string[]): Promise<Result<void, RepositoryError>>;
+}
+export interface IDeleteMultipleEntriesRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IDeleteMultipleEntriesRepositoryErrors[keyof IDeleteMultipleEntriesRepositoryErrors];
+export declare const DeleteMultipleEntriesRepository: import("@webiny/di").Abstraction<IDeleteMultipleEntriesRepository>;
+export declare namespace DeleteMultipleEntriesRepository {
+    type Interface = IDeleteMultipleEntriesRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/DeleteMultipleEntries/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const DeleteMultipleEntriesUseCase = createAbstraction("DeleteMultipleEntriesUseCase");
+const DeleteMultipleEntriesRepository = createAbstraction("DeleteMultipleEntriesRepository");
+export { DeleteMultipleEntriesRepository, DeleteMultipleEntriesUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentEntry/DeleteMultipleEntries/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/DeleteMultipleEntries/abstractions.js","sources":["../../../../src/features/contentEntry/DeleteMultipleEntries/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsModel } from \"~/types/index.js\";\nimport type {\n    EntryNotAuthorizedError,\n    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * DeleteMultipleEntries Use Case - Deletes multiple entries at once.\n */\n\nexport interface IDeleteMultipleEntriesUseCaseResultItem {\n    id: string;\n}\nexport interface IDeleteMultipleEntriesUseCaseParams {\n    entries: string[];\n}\nexport interface IDeleteMultipleEntriesUseCase {\n    execute(\n        model: CmsModel,\n        params: IDeleteMultipleEntriesUseCaseParams\n    ): Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;\n}\n\nexport interface IDeleteMultipleEntriesUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IDeleteMultipleEntriesUseCaseErrors[keyof IDeleteMultipleEntriesUseCaseErrors];\n\n/** Delete multiple content entries in batch. */\nexport const DeleteMultipleEntriesUseCase = createAbstraction<IDeleteMultipleEntriesUseCase>(\n    \"DeleteMultipleEntriesUseCase\"\n);\n\nexport namespace DeleteMultipleEntriesUseCase {\n    export type Interface = IDeleteMultipleEntriesUseCase;\n    export type Params = IDeleteMultipleEntriesUseCaseParams;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;\n}\n\n/**\n * Payload for before delete multiple event\n */\nexport interface EntryBeforeDeleteMultipleEventPayload {\n    entries: CmsEntry[];\n    ids: string[];\n    model: CmsModel;\n}\n\n/**\n * Payload for after delete multiple event\n */\nexport interface EntryAfterDeleteMultipleEventPayload {\n    entries: CmsEntry[];\n    ids: string[];\n    model: CmsModel;\n}\n\n/**\n * Payload for delete multiple error event\n */\nexport interface EntryDeleteMultipleErrorEventPayload {\n    entries: CmsEntry[];\n    ids: string[];\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.\n */\nexport interface IDeleteMultipleEntriesRepository {\n    execute(model: CmsModel, entryIds: string[]): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IDeleteMultipleEntriesRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError =\n    IDeleteMultipleEntriesRepositoryErrors[keyof IDeleteMultipleEntriesRepositoryErrors];\n\nexport const DeleteMultipleEntriesRepository = createAbstraction<IDeleteMultipleEntriesRepository>(\n    \"DeleteMultipleEntriesRepository\"\n);\n\nexport namespace DeleteMultipleEntriesRepository {\n    export type Interface = IDeleteMultipleEntriesRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["DeleteMultipleEntriesUseCase","createAbstraction","DeleteMultipleEntriesRepository"],"mappings":";AAgCO,MAAMA,+BAA+BC,kBACxC;AAqDG,MAAMC,kCAAkCD,kBAC3C"}