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

package/features/contentEntry/MoveEntry/MoveEntryUseCase.d.ts

@@ -0,0 +1,27 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { MoveEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { MoveEntryRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../../../features/contentEntry/GetRevisionById/index.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * MoveEntryUseCase - Orchestrates moving an entry to a different folder.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Get the entry to move
+ * - Check if entry is already in target folder (early return)
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+declare class MoveEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private getRevisionById;
+    private eventPublisher;
+    constructor(repository: MoveEntryRepository.Interface, accessControl: AccessControl.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, eventPublisher: EventPublisher.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string, folderId: string): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+}
+export declare const MoveEntryUseCase: import("@webiny/di").Implementation<typeof MoveEntryUseCaseImpl>;
+export {};

package/features/contentEntry/MoveEntry/MoveEntryUseCase.js

@@ -0,0 +1,104 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { MoveEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { MoveEntryRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../GetRevisionById/index.js";
+import { EntryBeforeMoveEvent, EntryAfterMoveEvent, EntryMoveErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * MoveEntryUseCase - Orchestrates moving an entry to a different folder.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Get the entry to move
+ * - Check if entry is already in target folder (early return)
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+class MoveEntryUseCaseImpl {
+  constructor(repository, accessControl, getRevisionById, eventPublisher) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+    this.getRevisionById = getRevisionById;
+    this.eventPublisher = eventPublisher;
+  }
+  async execute(model, id, folderId) {
+    // Check access control
+    const canAccess = await this.accessControl.canAccessEntry({
+      model,
+      rwd: "w"
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Get the entry to move
+    const result = await this.getRevisionById.execute(model, id);
+    if (result.isFail()) {
+      return Result.fail(new EntryNotFoundError(id));
+    }
+    const entry = result.value;
+
+    // Check access control on the specific entry
+    const canAccessEntry = await this.accessControl.canAccessEntry({
+      model,
+      entry,
+      rwd: "w"
+    });
+    if (!canAccessEntry) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Early return if entry is already in the requested folder
+    if (entry.location?.folderId === folderId) {
+      return Result.ok(entry);
+    }
+    try {
+      // Publish before event
+      await this.eventPublisher.publish(new EntryBeforeMoveEvent({
+        entry,
+        model,
+        folderId
+      }));
+
+      // Delegate to repository
+      const moveResult = await this.repository.execute(model, id, folderId);
+      if (moveResult.isFail()) {
+        await this.eventPublisher.publish(new EntryMoveErrorEvent({
+          entry,
+          model,
+          folderId,
+          error: moveResult.error
+        }));
+        return Result.fail(moveResult.error);
+      }
+
+      // Publish after event
+      await this.eventPublisher.publish(new EntryAfterMoveEvent({
+        entry,
+        model,
+        folderId
+      }));
+      return Result.ok(entry);
+    } catch (error) {
+      await this.eventPublisher.publish(new EntryMoveErrorEvent({
+        entry,
+        model,
+        folderId,
+        error: error
+      }));
+      return Result.fail(error);
+    }
+  }
+}
+export const MoveEntryUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: MoveEntryUseCaseImpl,
+  dependencies: [MoveEntryRepository, AccessControl, GetRevisionByIdUseCase, EventPublisher]
+});
+
+//# sourceMappingURL=MoveEntryUseCase.js.map

package/features/contentEntry/MoveEntry/MoveEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","EventPublisher","MoveEntryUseCase","UseCaseAbstraction","MoveEntryRepository","AccessControl","GetRevisionByIdUseCase","EntryBeforeMoveEvent","EntryAfterMoveEvent","EntryMoveErrorEvent","EntryNotAuthorizedError","EntryNotFoundError","MoveEntryUseCaseImpl","constructor","repository","accessControl","getRevisionById","eventPublisher","execute","model","id","folderId","canAccess","canAccessEntry","rwd","fail","fromModel","result","isFail","entry","value","location","ok","publish","moveResult","error","abstraction","implementation","dependencies"],"sources":["MoveEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport { MoveEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { MoveEntryRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { GetRevisionByIdUseCase } from \"~/features/contentEntry/GetRevisionById/index.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { EntryBeforeMoveEvent, EntryAfterMoveEvent, EntryMoveErrorEvent } from \"./events.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * MoveEntryUseCase - Orchestrates moving an entry to a different folder.\n *\n * Responsibilities:\n * - Apply access control\n * - Get the entry to move\n * - Check if entry is already in target folder (early return)\n * - Publish domain events\n * - Delegate to repository for storage operations\n */\nclass MoveEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: MoveEntryRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string,\n        folderId: string\n    ): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>> {\n        // Check access control\n        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"w\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Get the entry to move\n        const result = await this.getRevisionById.execute<T>(model, id);\n\n        if (result.isFail()) {\n            return Result.fail(new EntryNotFoundError(id));\n        }\n\n        const entry = result.value;\n\n        // Check access control on the specific entry\n        const canAccessEntry = await this.accessControl.canAccessEntry({\n            model,\n            entry,\n            rwd: \"w\"\n        });\n\n        if (!canAccessEntry) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Early return if entry is already in the requested folder\n        if (entry.location?.folderId === folderId) {\n            return Result.ok(entry);\n        }\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryBeforeMoveEvent({\n                    entry,\n                    model,\n                    folderId\n                })\n            );\n\n            // Delegate to repository\n            const moveResult = await this.repository.execute(model, id, folderId);\n\n            if (moveResult.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryMoveErrorEvent({\n                        entry,\n                        model,\n                        folderId,\n                        error: moveResult.error\n                    })\n                );\n                return Result.fail(moveResult.error);\n            }\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterMoveEvent({\n                    entry,\n                    model,\n                    folderId\n                })\n            );\n\n            return Result.ok(entry);\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryMoveErrorEvent({\n                    entry,\n                    model,\n                    folderId,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const MoveEntryUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: MoveEntryUseCaseImpl,\n    dependencies: [MoveEntryRepository, AccessControl, GetRevisionByIdUseCase, EventPublisher]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,62 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryNotFoundError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * MoveEntry Use Case - Moves an entry to a different folder.
+ */
+export interface IMoveEntryUseCase {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string, folderId: string): Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+export interface IMoveEntryUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    notFound: EntryNotFoundError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IMoveEntryUseCaseErrors[keyof IMoveEntryUseCaseErrors];
+export declare const MoveEntryUseCase: import("@webiny/di").Abstraction<IMoveEntryUseCase>;
+export declare namespace MoveEntryUseCase {
+    type Interface = IMoveEntryUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+/**
+ * Payload for before move event
+ */
+export interface EntryBeforeMoveEventPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+    folderId: string;
+}
+/**
+ * Payload for after move event
+ */
+export interface EntryAfterMoveEventPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+    folderId: string;
+}
+/**
+ * Payload for move error event
+ */
+export interface EntryMoveErrorEventPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+    folderId: string;
+    error: Error;
+}
+/**
+ * MoveEntryRepository - Handles storage operations for moving entries.
+ */
+export interface IMoveEntryRepository {
+    execute(model: CmsModel, id: string, folderId: string): Promise<Result<void, RepositoryError>>;
+}
+export interface IMoveEntryRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IMoveEntryRepositoryErrors[keyof IMoveEntryRepositoryErrors];
+export declare const MoveEntryRepository: import("@webiny/di").Abstraction<IMoveEntryRepository>;
+export declare namespace MoveEntryRepository {
+    type Interface = IMoveEntryRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/MoveEntry/abstractions.js

@@ -0,0 +1,27 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * MoveEntry Use Case - Moves an entry to a different folder.
+ */
+
+export const MoveEntryUseCase = createAbstraction("MoveEntryUseCase");
+
+/**
+ * Payload for before move event
+ */
+
+/**
+ * Payload for after move event
+ */
+
+/**
+ * Payload for move error event
+ */
+
+/**
+ * MoveEntryRepository - Handles storage operations for moving entries.
+ */
+
+export const MoveEntryRepository = createAbstraction("MoveEntryRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","MoveEntryUseCase","MoveEntryRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport type {\n    EntryNotAuthorizedError,\n    EntryNotFoundError,\n    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * MoveEntry Use Case - Moves an entry to a different folder.\n */\nexport interface IMoveEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string,\n        folderId: string\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IMoveEntryUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IMoveEntryUseCaseErrors[keyof IMoveEntryUseCaseErrors];\n\nexport const MoveEntryUseCase = createAbstraction<IMoveEntryUseCase>(\"MoveEntryUseCase\");\n\nexport namespace MoveEntryUseCase {\n    export type Interface = IMoveEntryUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<\n        Result<CmsEntry<T>, UseCaseError>\n    >;\n}\n\n/**\n * Payload for before move event\n */\nexport interface EntryBeforeMoveEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    folderId: string;\n}\n\n/**\n * Payload for after move event\n */\nexport interface EntryAfterMoveEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    folderId: string;\n}\n\n/**\n * Payload for move error event\n */\nexport interface EntryMoveErrorEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    folderId: string;\n    error: Error;\n}\n\n/**\n * MoveEntryRepository - Handles storage operations for moving entries.\n */\nexport interface IMoveEntryRepository {\n    execute(model: CmsModel, id: string, folderId: string): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IMoveEntryRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError = IMoveEntryRepositoryErrors[keyof IMoveEntryRepositoryErrors];\n\nexport const MoveEntryRepository = createAbstraction<IMoveEntryRepository>(\"MoveEntryRepository\");\n\nexport namespace MoveEntryRepository {\n    export type Interface = IMoveEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAQ/D;AACA;AACA;;AAiBA,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,kBAAkB,CAAC;;AAUxF;AACA;AACA;;AAOA;AACA;AACA;;AAOA;AACA;AACA;;AAQA;AACA;AACA;;AAWA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC","ignoreList":[]}

package/features/contentEntry/MoveEntry/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 { EntryAfterMoveEventPayload, EntryBeforeMoveEventPayload, EntryMoveErrorEventPayload } from "./abstractions.js";
+/**
+ * Before move entry event
+ */
+export declare class EntryBeforeMoveEvent extends DomainEvent<EntryBeforeMoveEventPayload> {
+    eventType: "Cms/Entry/BeforeMove";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeMoveEvent>>;
+}
+export declare const EntryBeforeMoveEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeMoveEvent>>;
+export declare namespace EntryBeforeMoveEventHandler {
+    type Interface = IEventHandler<EntryBeforeMoveEvent>;
+    type Event = EntryBeforeMoveEvent;
+}
+/**
+ * After move entry event
+ */
+export declare class EntryAfterMoveEvent extends DomainEvent<EntryAfterMoveEventPayload> {
+    eventType: "Cms/Entry/AfterMove";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterMoveEvent>>;
+}
+export declare const EntryAfterMoveEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterMoveEvent>>;
+export declare namespace EntryAfterMoveEventHandler {
+    type Interface = IEventHandler<EntryAfterMoveEvent>;
+    type Event = EntryAfterMoveEvent;
+}
+/**
+ * Move entry error event
+ */
+export declare class EntryMoveErrorEvent extends DomainEvent<EntryMoveErrorEventPayload> {
+    eventType: "Cms/Entry/MoveError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryMoveErrorEvent>>;
+}
+export declare const EntryMoveErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryMoveErrorEvent>>;
+export declare namespace EntryMoveErrorEventHandler {
+    type Interface = IEventHandler<EntryMoveErrorEvent>;
+    type Event = EntryMoveErrorEvent;
+}

package/features/contentEntry/MoveEntry/events.js

@@ -0,0 +1,34 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+/**
+ * Before move entry event
+ */
+export class EntryBeforeMoveEvent extends DomainEvent {
+  eventType = "Cms/Entry/BeforeMove";
+  getHandlerAbstraction() {
+    return EntryBeforeMoveEventHandler;
+  }
+}
+export const EntryBeforeMoveEventHandler = createAbstraction("EntryBeforeMoveEventHandler");
+/**
+ * After move entry event
+ */
+export class EntryAfterMoveEvent extends DomainEvent {
+  eventType = "Cms/Entry/AfterMove";
+  getHandlerAbstraction() {
+    return EntryAfterMoveEventHandler;
+  }
+}
+export const EntryAfterMoveEventHandler = createAbstraction("EntryAfterMoveEventHandler");
+/**
+ * Move entry error event
+ */
+export class EntryMoveErrorEvent extends DomainEvent {
+  eventType = "Cms/Entry/MoveError";
+  getHandlerAbstraction() {
+    return EntryMoveErrorEventHandler;
+  }
+}
+export const EntryMoveErrorEventHandler = createAbstraction("EntryMoveErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforeMoveEvent","eventType","getHandlerAbstraction","EntryBeforeMoveEventHandler","EntryAfterMoveEvent","EntryAfterMoveEventHandler","EntryMoveErrorEvent","EntryMoveErrorEventHandler"],"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    EntryAfterMoveEventPayload,\n    EntryBeforeMoveEventPayload,\n    EntryMoveErrorEventPayload\n} from \"./abstractions.js\";\n\n/**\n * Before move entry event\n */\nexport class EntryBeforeMoveEvent extends DomainEvent<EntryBeforeMoveEventPayload> {\n    eventType = \"Cms/Entry/BeforeMove\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeMoveEventHandler;\n    }\n}\n\nexport const EntryBeforeMoveEventHandler = createAbstraction<IEventHandler<EntryBeforeMoveEvent>>(\n    \"EntryBeforeMoveEventHandler\"\n);\n\nexport namespace EntryBeforeMoveEventHandler {\n    export type Interface = IEventHandler<EntryBeforeMoveEvent>;\n    export type Event = EntryBeforeMoveEvent;\n}\n\n/**\n * After move entry event\n */\nexport class EntryAfterMoveEvent extends DomainEvent<EntryAfterMoveEventPayload> {\n    eventType = \"Cms/Entry/AfterMove\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterMoveEventHandler;\n    }\n}\n\nexport const EntryAfterMoveEventHandler = createAbstraction<IEventHandler<EntryAfterMoveEvent>>(\n    \"EntryAfterMoveEventHandler\"\n);\n\nexport namespace EntryAfterMoveEventHandler {\n    export type Interface = IEventHandler<EntryAfterMoveEvent>;\n    export type Event = EntryAfterMoveEvent;\n}\n\n/**\n * Move entry error event\n */\nexport class EntryMoveErrorEvent extends DomainEvent<EntryMoveErrorEventPayload> {\n    eventType = \"Cms/Entry/MoveError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryMoveErrorEventHandler;\n    }\n}\n\nexport const EntryMoveErrorEventHandler = createAbstraction<IEventHandler<EntryMoveErrorEvent>>(\n    \"EntryMoveErrorEventHandler\"\n);\n\nexport namespace EntryMoveErrorEventHandler {\n    export type Interface = IEventHandler<EntryMoveErrorEvent>;\n    export type Event = EntryMoveErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;AAOtE;AACA;AACA;AACA,OAAO,MAAMC,oBAAoB,SAASD,WAAW,CAA8B;EAC/EE,SAAS,GAAG,sBAAsB;EAElCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,2BAA2B;EACtC;AACJ;AAEA,OAAO,MAAMA,2BAA2B,GAAGL,iBAAiB,CACxD,6BACJ,CAAC;AAOD;AACA;AACA;AACA,OAAO,MAAMM,mBAAmB,SAASL,WAAW,CAA6B;EAC7EE,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,0BAA0B;EACrC;AACJ;AAEA,OAAO,MAAMA,0BAA0B,GAAGP,iBAAiB,CACvD,4BACJ,CAAC;AAOD;AACA;AACA;AACA,OAAO,MAAMQ,mBAAmB,SAASP,WAAW,CAA6B;EAC7EE,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,0BAA0B;EACrC;AACJ;AAEA,OAAO,MAAMA,0BAA0B,GAAGT,iBAAiB,CACvD,4BACJ,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/MoveEntry/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","MoveEntryUseCase","MoveEntryRepository","MoveEntryFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { MoveEntryUseCase } from \"./MoveEntryUseCase.js\";\nimport { MoveEntryRepository } from \"./MoveEntryRepository.js\";\n\nexport const MoveEntryFeature = createFeature({\n    name: \"MoveEntry\",\n    register(container) {\n        // Register repository (singleton scope)\n        container.register(MoveEntryRepository).inSingletonScope();\n\n        // Register use case (transient scope)\n        container.register(MoveEntryUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gBAAgB;AACzB,SAASC,mBAAmB;AAE5B,OAAO,MAAMC,gBAAgB,GAAGH,aAAa,CAAC;EAC1CI,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC,CAACK,gBAAgB,CAAC,CAAC;;IAE1D;IACAD,SAAS,CAACD,QAAQ,CAACJ,gBAAgB,CAAC;EACxC;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { MoveEntryUseCase, MoveEntryRepository } from "./abstractions.js";
+export { EntryAfterMoveEventHandler, EntryBeforeMoveEventHandler } from "./events.js";

package/features/contentEntry/MoveEntry/index.js

@@ -0,0 +1,4 @@
+export { MoveEntryUseCase, MoveEntryRepository } from "./abstractions.js";
+export { EntryAfterMoveEventHandler, EntryBeforeMoveEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["MoveEntryUseCase","MoveEntryRepository","EntryAfterMoveEventHandler","EntryBeforeMoveEventHandler"],"sources":["index.ts"],"sourcesContent":["export { MoveEntryUseCase, MoveEntryRepository } from \"./abstractions.js\";\nexport { EntryAfterMoveEventHandler, EntryBeforeMoveEventHandler } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB,EAAEC,mBAAmB;AAC9C,SAASC,0BAA0B,EAAEC,2BAA2B","ignoreList":[]}

package/features/contentEntry/PublishEntry/PublishEntryRepository.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "@webiny/feature/api";
+import { PublishEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import { EntryFromStorageTransform, EntryToStorageTransform } from "../../../legacy/abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * PublishEntryRepository - Handles storage operations for publishing entries.
+ *
+ * Responsibilities:
+ * - Transform entry to storage format
+ * - Publish the entry in storage
+ * - Transform result back from storage format
+ * - Handle storage errors
+ */
+declare class PublishEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private entryToStorageTransform;
+    private entryFromStorageTransform;
+    private storageOperations;
+    constructor(entryToStorageTransform: EntryToStorageTransform.Interface, entryFromStorageTransform: EntryFromStorageTransform.Interface, storageOperations: StorageOperations.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, entry: CmsEntry<T>): Promise<Result<CmsEntry<T>, RepositoryAbstraction.Error>>;
+}
+export declare const PublishEntryRepository: import("@webiny/di").Implementation<typeof PublishEntryRepositoryImpl>;
+export {};

package/features/contentEntry/PublishEntry/PublishEntryRepository.js

@@ -0,0 +1,47 @@
+import { createImplementation, Result } from "@webiny/feature/api";
+import { PublishEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryFromStorageTransform, EntryToStorageTransform } from "../../../legacy/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * PublishEntryRepository - Handles storage operations for publishing entries.
+ *
+ * Responsibilities:
+ * - Transform entry to storage format
+ * - Publish the entry in storage
+ * - Transform result back from storage format
+ * - Handle storage errors
+ */
+class PublishEntryRepositoryImpl {
+  constructor(entryToStorageTransform, entryFromStorageTransform, storageOperations) {
+    this.entryToStorageTransform = entryToStorageTransform;
+    this.entryFromStorageTransform = entryFromStorageTransform;
+    this.storageOperations = storageOperations;
+  }
+  async execute(model, entry) {
+    try {
+      // Transform entry to storage format
+      const storageEntry = await this.entryToStorageTransform(model, entry);
+
+      // Publish the entry
+      const result = await this.storageOperations.entries.publish(model, {
+        entry,
+        storageEntry
+      });
+
+      // Transform result back from storage format
+      const transformedEntry = await this.entryFromStorageTransform(model, result);
+      return Result.ok(transformedEntry);
+    } catch (error) {
+      return Result.fail(new EntryPersistenceError(error));
+    }
+  }
+}
+export const PublishEntryRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: PublishEntryRepositoryImpl,
+  dependencies: [EntryToStorageTransform, EntryFromStorageTransform, StorageOperations]
+});
+
+//# sourceMappingURL=PublishEntryRepository.js.map

package/features/contentEntry/PublishEntry/PublishEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","PublishEntryRepository","RepositoryAbstraction","StorageOperations","EntryFromStorageTransform","EntryToStorageTransform","EntryPersistenceError","PublishEntryRepositoryImpl","constructor","entryToStorageTransform","entryFromStorageTransform","storageOperations","execute","model","entry","storageEntry","result","entries","publish","transformedEntry","ok","error","fail","abstraction","implementation","dependencies"],"sources":["PublishEntryRepository.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport { PublishEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { EntryFromStorageTransform, EntryToStorageTransform } from \"~/legacy/abstractions.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * PublishEntryRepository - Handles storage operations for publishing entries.\n *\n * Responsibilities:\n * - Transform entry to storage format\n * - Publish the entry in storage\n * - Transform result back from storage format\n * - Handle storage errors\n */\nclass PublishEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private entryToStorageTransform: EntryToStorageTransform.Interface,\n        private entryFromStorageTransform: EntryFromStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<CmsEntry<T>, RepositoryAbstraction.Error>> {\n        try {\n            // Transform entry to storage format\n            const storageEntry = await this.entryToStorageTransform(model, entry);\n\n            // Publish the entry\n            const result = await this.storageOperations.entries.publish(model, {\n                entry,\n                storageEntry\n            });\n\n            // Transform result back from storage format\n            const transformedEntry = await this.entryFromStorageTransform(model, result);\n\n            return Result.ok(transformedEntry);\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const PublishEntryRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: PublishEntryRepositoryImpl,\n    dependencies: [EntryToStorageTransform, EntryFromStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,EAAEC,MAAM,QAAQ,qBAAqB;AAClE,SAASC,sBAAsB,IAAIC,qBAAqB;AACxD,SAASC,iBAAiB;AAC1B,SAASC,yBAAyB,EAAEC,uBAAuB;AAE3D,SAASC,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,0BAA0B,CAA4C;EACjEC,WAAWA,CACNC,uBAA0D,EAC1DC,yBAA8D,EAC9DC,iBAA8C,EACxD;IAAA,KAHUF,uBAA0D,GAA1DA,uBAA0D;IAAA,KAC1DC,yBAA8D,GAA9DA,yBAA8D;IAAA,KAC9DC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAaC,OAAOA,CAChBC,KAAe,EACfC,KAAkB,EACuC;IACzD,IAAI;MACA;MACA,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACN,uBAAuB,CAACI,KAAK,EAAEC,KAAK,CAAC;;MAErE;MACA,MAAME,MAAM,GAAG,MAAM,IAAI,CAACL,iBAAiB,CAACM,OAAO,CAACC,OAAO,CAACL,KAAK,EAAE;QAC/DC,KAAK;QACLC;MACJ,CAAC,CAAC;;MAEF;MACA,MAAMI,gBAAgB,GAAG,MAAM,IAAI,CAACT,yBAAyB,CAACG,KAAK,EAAEG,MAAM,CAAC;MAE5E,OAAOhB,MAAM,CAACoB,EAAE,CAACD,gBAAgB,CAAC;IACtC,CAAC,CAAC,OAAOE,KAAK,EAAE;MACZ,OAAOrB,MAAM,CAACsB,IAAI,CAAC,IAAIhB,qBAAqB,CAACe,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMpB,sBAAsB,GAAGF,oBAAoB,CAAC;EACvDwB,WAAW,EAAErB,qBAAqB;EAClCsB,cAAc,EAAEjB,0BAA0B;EAC1CkB,YAAY,EAAE,CAACpB,uBAAuB,EAAED,yBAAyB,EAAED,iBAAiB;AACxF,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/PublishEntry/PublishEntryUseCase.d.ts

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { PublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { PublishEntryRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../../../features/contentEntry/GetRevisionById/index.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import { CmsContext } from "../../../features/shared/abstractions.js";
+/**
+ * PublishEntryUseCase - Orchestrates publishing an entry.
+ *
+ * Responsibilities:
+ * - Apply access control (publish permission)
+ * - Get the entry to publish
+ * - Get the latest revision for entry-level metadata
+ * - Prepare entry data with publish metadata
+ * - Validate entry data
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+declare class PublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private getRevisionById;
+    private getLatestRevision;
+    private identityContext;
+    private eventPublisher;
+    private cmsContext;
+    constructor(repository: PublishEntryRepository.Interface, accessControl: AccessControl.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface, identityContext: IdentityContext.Interface, eventPublisher: EventPublisher.Interface, cmsContext: CmsContext.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+}
+export declare const PublishEntryUseCase: import("@webiny/di").Implementation<typeof PublishEntryUseCaseImpl>;
+export {};

package/features/contentEntry/PublishEntry/PublishEntryUseCase.js

@@ -0,0 +1,129 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { PublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { PublishEntryRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../GetRevisionById/index.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../GetLatestRevisionByEntryId/index.js";
+import { EntryBeforePublishEvent, EntryAfterPublishEvent, EntryPublishErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+import { createPublishEntryData } from "../../../crud/contentEntry/entryDataFactories/index.js";
+import { CmsContext } from "../../shared/abstractions.js";
+
+/**
+ * PublishEntryUseCase - Orchestrates publishing an entry.
+ *
+ * Responsibilities:
+ * - Apply access control (publish permission)
+ * - Get the entry to publish
+ * - Get the latest revision for entry-level metadata
+ * - Prepare entry data with publish metadata
+ * - Validate entry data
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+class PublishEntryUseCaseImpl {
+  constructor(repository, accessControl, getRevisionById, getLatestRevision, identityContext, eventPublisher, cmsContext) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+    this.getRevisionById = getRevisionById;
+    this.getLatestRevision = getLatestRevision;
+    this.identityContext = identityContext;
+    this.eventPublisher = eventPublisher;
+    this.cmsContext = cmsContext;
+  }
+  async execute(model, id) {
+    // Check access control (publish permission)
+    const canAccess = await this.accessControl.canAccessEntry({
+      model,
+      pw: "p"
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Get the entry to publish
+    const result = await this.getRevisionById.execute(model, id);
+    if (result.isFail()) {
+      return Result.fail(new EntryNotFoundError(id));
+    }
+    const originalEntry = result.value;
+
+    // Check access control on the specific entry
+    const canAccessEntry = await this.accessControl.canAccessEntry({
+      model,
+      entry: originalEntry,
+      pw: "p"
+    });
+    if (!canAccessEntry) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Get the latest revision for entry-level metadata
+    const latestResult = await this.getLatestRevision.execute(model, {
+      id: originalEntry.entryId
+    });
+    if (latestResult.isFail()) {
+      return Result.fail(latestResult.error);
+    }
+    const latestEntry = latestResult.value;
+
+    // Prepare entry data for publishing (includes validation)
+    const {
+      entry
+    } = await createPublishEntryData({
+      context: this.cmsContext,
+      model,
+      originalEntry,
+      latestEntry,
+      getIdentity: () => this.identityContext.getIdentity()
+    });
+    try {
+      // Publish before event
+      await this.eventPublisher.publish(new EntryBeforePublishEvent({
+        entry,
+        original: originalEntry,
+        model
+      }));
+
+      // Delegate to repository
+      const repositoryResult = await this.repository.execute(model, entry);
+      if (repositoryResult.isFail()) {
+        await this.eventPublisher.publish(new EntryPublishErrorEvent({
+          entry,
+          original: originalEntry,
+          model,
+          error: repositoryResult.error
+        }));
+        return Result.fail(repositoryResult.error);
+      }
+      const publishedEntry = repositoryResult.value;
+
+      // Publish after event
+      await this.eventPublisher.publish(new EntryAfterPublishEvent({
+        entry: publishedEntry,
+        original: originalEntry,
+        model
+      }));
+      return Result.ok(entry);
+    } catch (error) {
+      await this.eventPublisher.publish(new EntryPublishErrorEvent({
+        entry,
+        original: originalEntry,
+        model,
+        error: error
+      }));
+      return Result.fail(error);
+    }
+  }
+}
+export const PublishEntryUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: PublishEntryUseCaseImpl,
+  dependencies: [PublishEntryRepository, AccessControl, GetRevisionByIdUseCase, GetLatestRevisionByEntryIdUseCase, IdentityContext, EventPublisher, CmsContext]
+});
+
+//# sourceMappingURL=PublishEntryUseCase.js.map