@webiny/api-headless-cms 6.0.0-beta.0 → 6.0.0-rc.1

package/features/contentEntry/DeleteEntryRevision/DeleteEntryRevisionUseCase.js

@@ -0,0 +1,141 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { DeleteEntryRevisionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteEntryRevisionRepository } 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";
+import { EntryRevisionBeforeDeleteEvent, EntryRevisionAfterDeleteEvent, EntryRevisionDeleteErrorEvent } from "./events.js";
+import { parseIdentifier } from "@webiny/utils";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * DeleteEntryRevisionUseCase - Orchestrates deletion of a specific entry revision.
+ *
+ * Responsibilities:
+ * - Parse revision ID to extract entry ID and version
+ * - Apply access control
+ * - Get the revision to delete
+ * - Determine if this is the latest revision
+ * - If latest and no previous revision exists, perform full entry delete
+ * - If latest and previous exists, set previous as new latest
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+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) {
+    // Check access control
+    const canAccess = await this.accessControl.canAccessEntry({
+      model,
+      rwd: "d"
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+    const {
+      id: entryId,
+      version
+    } = parseIdentifier(revisionId);
+
+    // Get the revision to delete
+    const getRevisionResult = await this.getRevisionById.execute(model, revisionId);
+    if (getRevisionResult.isFail()) {
+      return Result.fail(getRevisionResult.error);
+    }
+    const entryToDelete = getRevisionResult.value;
+
+    // Check access control on the specific entry
+    const canAccessEntry = await this.accessControl.canAccessEntry({
+      model,
+      entry: entryToDelete,
+      rwd: "d"
+    });
+    if (!canAccessEntry) {
+      return Result.fail(new EntryNotAuthorizedError());
+    }
+
+    // Get the latest revision
+    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;
+
+    // Get the previous revision
+    const previousRevisionResult = await this.getPreviousRevision.execute(model, {
+      entryId,
+      version: version
+    });
+
+    // If targeted record is the latest entry record and there is no previous revision,
+    // delete the entire entry.
+    const previousRevision = previousRevisionResult.isFail() ? null : previousRevisionResult.value;
+    if (previousRevisionResult.isFail() && entryToDelete.id === latestRevisionId) {
+      return await this.deleteEntry.execute(model, revisionId, {});
+    }
+
+    // Determine the entry to set as latest (if deleting current latest)
+    let latestEntry = null;
+    if (entryToDelete.id === latestRevisionId && previousRevision) {
+      latestEntry = previousRevision;
+    }
+    try {
+      // Publish before event
+      await this.eventPublisher.publish(new EntryRevisionBeforeDeleteEvent({
+        entry: entryToDelete,
+        model
+      }));
+
+      // Delegate to repository
+      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);
+      }
+
+      // Publish after event
+      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);
+    }
+  }
+}
+export const DeleteEntryRevisionUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: DeleteEntryRevisionUseCaseImpl,
+  dependencies: [DeleteEntryRevisionRepository, AccessControl, GetRevisionByIdUseCase, GetLatestRevisionByEntryIdIncludingDeletedUseCase, GetPreviousRevisionByEntryIdUseCase, DeleteEntryUseCase, EventPublisher]
+});
+
+//# sourceMappingURL=DeleteEntryRevisionUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","DeleteEntryRevisionUseCase","UseCaseAbstraction","DeleteEntryRevisionRepository","AccessControl","GetRevisionByIdUseCase","GetLatestRevisionByEntryIdIncludingDeletedUseCase","GetPreviousRevisionByEntryIdUseCase","DeleteEntryUseCase","EventPublisher","EntryRevisionBeforeDeleteEvent","EntryRevisionAfterDeleteEvent","EntryRevisionDeleteErrorEvent","parseIdentifier","EntryNotAuthorizedError","DeleteEntryRevisionUseCaseImpl","constructor","repository","accessControl","getRevisionById","getLatestRevision","getPreviousRevision","deleteEntry","eventPublisher","execute","model","revisionId","canAccess","canAccessEntry","rwd","fail","fromModel","id","entryId","version","getRevisionResult","isFail","error","entryToDelete","value","entry","latestRevisionResult","latestRevision","latestRevisionId","previousRevisionResult","previousRevision","latestEntry","publish","result","ok","abstraction","implementation","dependencies"],"sources":["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\";\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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,64 @@
+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];
+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,28 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * DeleteEntryRevision Use Case - Deletes a specific revision of an entry.
+ * Handles special cases like deleting the latest revision.
+ */
+
+export const DeleteEntryRevisionUseCase = createAbstraction("DeleteEntryRevisionUseCase");
+
+/**
+ * Payload for before delete event
+ */
+
+/**
+ * Payload for after delete event
+ */
+
+/**
+ * Payload for delete error event
+ */
+
+/**
+ * DeleteEntryRevisionRepository - Handles storage operations for deleting entry revisions.
+ */
+
+export const DeleteEntryRevisionRepository = createAbstraction("DeleteEntryRevisionRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DeleteEntryRevisionUseCase","DeleteEntryRevisionRepository"],"sources":["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\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"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAQ/D;AACA;AACA;AACA;;AAaA,OAAO,MAAMC,0BAA0B,GAAGD,iBAAiB,CACvD,4BACJ,CAAC;;AASD;AACA;AACA;;AAMA;AACA;AACA;;AAMA;AACA;AACA;;AAOA;AACA;AACA;;AAgBA,OAAO,MAAME,6BAA6B,GAAGF,iBAAiB,CAC1D,+BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,39 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+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>>;
+}
+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>>;
+}
+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,34 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+/**
+ * Before delete revision event
+ */
+export class EntryRevisionBeforeDeleteEvent extends DomainEvent {
+  eventType = "Cms/Entry/RevisionBeforeDelete";
+  getHandlerAbstraction() {
+    return EntryRevisionBeforeDeleteEventHandler;
+  }
+}
+export const EntryRevisionBeforeDeleteEventHandler = createAbstraction("EntryRevisionBeforeDeleteEventHandler");
+/**
+ * After delete revision event
+ */
+export class EntryRevisionAfterDeleteEvent extends DomainEvent {
+  eventType = "Cms/Entry/RevisionAfterDelete";
+  getHandlerAbstraction() {
+    return EntryRevisionAfterDeleteEventHandler;
+  }
+}
+export const EntryRevisionAfterDeleteEventHandler = createAbstraction("EntryRevisionAfterDeleteEventHandler");
+/**
+ * Delete revision error event
+ */
+export class EntryRevisionDeleteErrorEvent extends DomainEvent {
+  eventType = "Cms/Entry/RevisionDeleteError";
+  getHandlerAbstraction() {
+    return EntryRevisionDeleteErrorEventHandler;
+  }
+}
+export const EntryRevisionDeleteErrorEventHandler = createAbstraction("EntryRevisionDeleteErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","EntryRevisionBeforeDeleteEvent","eventType","getHandlerAbstraction","EntryRevisionBeforeDeleteEventHandler","EntryRevisionAfterDeleteEvent","EntryRevisionAfterDeleteEventHandler","EntryRevisionDeleteErrorEvent","EntryRevisionDeleteErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\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\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\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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;AAOtE;AACA;AACA;AACA,OAAO,MAAMC,8BAA8B,SAASD,WAAW,CAAmC;EAC9FE,SAAS,GAAG,gCAAgC;EAE5CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,qCAAqC;EAChD;AACJ;AAEA,OAAO,MAAMA,qCAAqC,GAAGL,iBAAiB,CAEpE,uCAAuC,CAAC;AAO1C;AACA;AACA;AACA,OAAO,MAAMM,6BAA6B,SAASL,WAAW,CAAkC;EAC5FE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,oCAAoC;EAC/C;AACJ;AAEA,OAAO,MAAMA,oCAAoC,GAAGP,iBAAiB,CAEnE,sCAAsC,CAAC;AAOzC;AACA;AACA;AACA,OAAO,MAAMQ,6BAA6B,SAASP,WAAW,CAAkC;EAC5FE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,oCAAoC;EAC/C;AACJ;AAEA,OAAO,MAAMA,oCAAoC,GAAGT,iBAAiB,CAEnE,sCAAsC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const DeleteEntryRevisionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/contentEntry/DeleteEntryRevision/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","DeleteEntryRevisionUseCase","DeleteEntryRevisionRepository","DeleteEntryRevisionFeature","name","register","container","inSingletonScope"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,0BAA0B;AACnC,SAASC,6BAA6B;AAEtC,OAAO,MAAMC,0BAA0B,GAAGH,aAAa,CAAC;EACpDI,IAAI,EAAE,qBAAqB;EAC3BC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,6BAA6B,CAAC,CAACK,gBAAgB,CAAC,CAAC;;IAEpE;IACAD,SAAS,CAACD,QAAQ,CAACJ,0BAA0B,CAAC;EAClD;AACJ,CAAC,CAAC","ignoreList":[]}

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,4 @@
+export { DeleteEntryRevisionUseCase, DeleteEntryRevisionRepository } from "./abstractions.js";
+export { EntryRevisionBeforeDeleteEventHandler, EntryRevisionAfterDeleteEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["DeleteEntryRevisionUseCase","DeleteEntryRevisionRepository","EntryRevisionBeforeDeleteEventHandler","EntryRevisionAfterDeleteEventHandler"],"sources":["index.ts"],"sourcesContent":["export { DeleteEntryRevisionUseCase, DeleteEntryRevisionRepository } from \"./abstractions.js\";\nexport {\n    EntryRevisionBeforeDeleteEventHandler,\n    EntryRevisionAfterDeleteEventHandler\n} from \"./events.js\";\n"],"mappings":"AAAA,SAASA,0BAA0B,EAAEC,6BAA6B;AAClE,SACIC,qCAAqC,EACrCC,oCAAoC","ignoreList":[]}

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,35 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { DeleteMultipleEntriesRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.
+ *
+ * Responsibilities:
+ * - Call storage operation to delete multiple entries
+ * - Handle storage errors
+ */
+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));
+    }
+  }
+}
+export const DeleteMultipleEntriesRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: DeleteMultipleEntriesRepositoryImpl,
+  dependencies: [StorageOperations]
+});
+
+//# sourceMappingURL=DeleteMultipleEntriesRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","DeleteMultipleEntriesRepository","RepositoryAbstraction","StorageOperations","EntryPersistenceError","DeleteMultipleEntriesRepositoryImpl","constructor","storageOperations","execute","model","entryIds","entries","deleteMultipleEntries","ok","error","fail","abstraction","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,+BAA+B,IAAIC,qBAAqB;AACjE,SAASC,iBAAiB;AAE1B,SAASC,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mCAAmC,CAA4C;EAC1EC,WAAWA,CAASC,iBAA8C,EAAE;IAAA,KAAhDA,iBAA8C,GAA9CA,iBAA8C;EAAG;EAE5E,MAAMC,OAAOA,CACTC,KAAe,EACfC,QAAkB,EACgC;IAClD,IAAI;MACA,MAAM,IAAI,CAACH,iBAAiB,CAACI,OAAO,CAACC,qBAAqB,CAACH,KAAK,EAAE;QAC9DE,OAAO,EAAED;MACb,CAAC,CAAC;MACF,OAAOX,MAAM,CAACc,EAAE,CAAC,CAAC;IACtB,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,OAAOf,MAAM,CAACgB,IAAI,CAAC,IAAIX,qBAAqB,CAACU,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMb,+BAA+B,GAAGD,oBAAoB,CAAC;EAChEgB,WAAW,EAAEd,qBAAqB;EAClCe,cAAc,EAAEZ,mCAAmC;EACnDa,YAAY,EAAE,CAACf,iBAAiB;AACpC,CAAC,CAAC","ignoreList":[]}

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";
+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,136 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { DeleteMultipleEntriesUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteMultipleEntriesRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { ListEntriesUseCase } from "../ListEntries/abstractions.js";
+import { EntryBeforeDeleteMultipleEvent, EntryAfterDeleteMultipleEvent, EntryDeleteMultipleErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { parseIdentifier } from "@webiny/utils";
+import WebinyError from "@webiny/error";
+import { filterAsync } from "../../../utils/filterAsync.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
+ */
+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;
+
+    // Parse entry IDs to unique entry IDs
+    const entryIdList = new Set();
+    for (const id of input) {
+      const {
+        id: entryId
+      } = parseIdentifier(id);
+      entryIdList.add(entryId);
+    }
+    const ids = Array.from(entryIdList);
+
+    // Validate max entries limit
+    if (ids.length > maxDeletableEntries) {
+      return Result.fail(new WebinyError("Cannot delete more than 50 entries at once.", "DELETE_ENTRIES_MAX", {
+        entries: ids
+      }));
+    }
+
+    // Check access control
+    const canAccess = await this.accessControl.canAccessEntry({
+      model,
+      rwd: "d"
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Fetch entries using ListEntries use case
+    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;
+
+    // Filter entries by access control (only delete entries user can access)
+    const accessibleEntries = await filterAsync(entries, async entry => {
+      return this.accessControl.canAccessEntry({
+        model,
+        entry
+      });
+    });
+    const items = accessibleEntries.map(entry => entry.id);
+    try {
+      // Publish before event
+      await this.eventPublisher.publish(new EntryBeforeDeleteMultipleEvent({
+        entries,
+        ids,
+        model
+      }));
+
+      // Delegate to repository
+      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);
+      }
+
+      // Publish after event
+      await this.eventPublisher.publish(new EntryAfterDeleteMultipleEvent({
+        entries,
+        ids,
+        model
+      }));
+      return Result.ok(items.map(id => {
+        return {
+          id
+        };
+      }));
+    } catch (error) {
+      await this.eventPublisher.publish(new EntryDeleteMultipleErrorEvent({
+        entries,
+        ids,
+        model,
+        error: error
+      }));
+      return Result.fail(error);
+    }
+  }
+}
+export const DeleteMultipleEntriesUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: DeleteMultipleEntriesUseCaseImpl,
+  dependencies: [DeleteMultipleEntriesRepository, AccessControl, ListEntriesUseCase, EventPublisher]
+});
+
+//# sourceMappingURL=DeleteMultipleEntriesUseCase.js.map