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

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","IdentityContext","EventPublisher","PublishEntryUseCase","UseCaseAbstraction","PublishEntryRepository","AccessControl","GetRevisionByIdUseCase","GetLatestRevisionByEntryIdUseCase","EntryBeforePublishEvent","EntryAfterPublishEvent","EntryPublishErrorEvent","EntryNotAuthorizedError","EntryNotFoundError","createPublishEntryData","CmsContext","PublishEntryUseCaseImpl","constructor","repository","accessControl","getRevisionById","getLatestRevision","identityContext","eventPublisher","cmsContext","execute","model","id","canAccess","canAccessEntry","pw","fail","fromModel","result","isFail","originalEntry","value","entry","latestResult","entryId","error","latestEntry","context","getIdentity","publish","original","repositoryResult","publishedEntry","ok","abstraction","implementation","dependencies"],"sources":["PublishEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport { PublishEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { PublishEntryRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { GetRevisionByIdUseCase } from \"~/features/contentEntry/GetRevisionById/index.js\";\nimport { GetLatestRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport {\n    EntryBeforePublishEvent,\n    EntryAfterPublishEvent,\n    EntryPublishErrorEvent\n} from \"./events.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\nimport { createPublishEntryData } from \"~/crud/contentEntry/entryDataFactories/index.js\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\n\n/**\n * PublishEntryUseCase - Orchestrates publishing an entry.\n *\n * Responsibilities:\n * - Apply access control (publish permission)\n * - Get the entry to publish\n * - Get the latest revision for entry-level metadata\n * - Prepare entry data with publish metadata\n * - Validate entry data\n * - Publish domain events\n * - Delegate to repository for storage operations\n */\nclass PublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: PublishEntryRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private cmsContext: CmsContext.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string\n    ): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>> {\n        // Check access control (publish permission)\n        const canAccess = await this.accessControl.canAccessEntry({ model, pw: \"p\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Get the entry to publish\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 originalEntry = result.value;\n\n        // Check access control on the specific entry\n        const canAccessEntry = await this.accessControl.canAccessEntry({\n            model,\n            entry: originalEntry,\n            pw: \"p\"\n        });\n\n        if (!canAccessEntry) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Get the latest revision for entry-level metadata\n        const latestResult = await this.getLatestRevision.execute<T>(model, {\n            id: originalEntry.entryId\n        });\n\n        if (latestResult.isFail()) {\n            return Result.fail(latestResult.error);\n        }\n\n        const latestEntry = latestResult.value;\n\n        // Prepare entry data for publishing (includes validation)\n        const { entry } = await createPublishEntryData<T>({\n            context: this.cmsContext,\n            model,\n            originalEntry,\n            latestEntry,\n            getIdentity: () => this.identityContext.getIdentity()\n        });\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryBeforePublishEvent({\n                    entry,\n                    original: originalEntry,\n                    model\n                })\n            );\n\n            // Delegate to repository\n            const repositoryResult = await this.repository.execute(model, entry);\n\n            if (repositoryResult.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryPublishErrorEvent({\n                        entry,\n                        original: originalEntry,\n                        model,\n                        error: repositoryResult.error\n                    })\n                );\n                return Result.fail(repositoryResult.error);\n            }\n\n            const publishedEntry = repositoryResult.value;\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterPublishEvent({\n                    entry: publishedEntry,\n                    original: originalEntry,\n                    model\n                })\n            );\n\n            return Result.ok(entry);\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryPublishErrorEvent({\n                    entry,\n                    original: originalEntry,\n                    model,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const PublishEntryUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: PublishEntryUseCaseImpl,\n    dependencies: [\n        PublishEntryRepository,\n        AccessControl,\n        GetRevisionByIdUseCase,\n        GetLatestRevisionByEntryIdUseCase,\n        IdentityContext,\n        EventPublisher,\n        CmsContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,63 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryNotFoundError, EntryPersistenceError, EntryValidationError } from "../../../domain/contentEntry/errors.js";
+/**
+ * PublishEntry Use Case - Publishes an entry revision.
+ */
+export interface IPublishEntryUseCase {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string): Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+export interface IPublishEntryUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    notFound: EntryNotFoundError;
+    validation: EntryValidationError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IPublishEntryUseCaseErrors[keyof IPublishEntryUseCaseErrors];
+export declare const PublishEntryUseCase: import("@webiny/di").Abstraction<IPublishEntryUseCase>;
+export declare namespace PublishEntryUseCase {
+    type Interface = IPublishEntryUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+/**
+ * Payload for before publish event
+ */
+export interface EntryBeforePublishEventPayload {
+    entry: CmsEntry;
+    original: CmsEntry;
+    model: CmsModel;
+}
+/**
+ * Payload for after publish event
+ */
+export interface EntryAfterPublishEventPayload {
+    entry: CmsEntry;
+    original: CmsEntry;
+    model: CmsModel;
+}
+/**
+ * Payload for publish error event
+ */
+export interface EntryPublishErrorEventPayload {
+    entry: CmsEntry;
+    original: CmsEntry;
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * PublishEntryRepository - Handles storage operations for publishing entries.
+ */
+export interface IPublishEntryRepository {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, entry: CmsEntry<T>): Promise<Result<CmsEntry<T>, RepositoryError>>;
+}
+export interface IPublishEntryRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IPublishEntryRepositoryErrors[keyof IPublishEntryRepositoryErrors];
+export declare const PublishEntryRepository: import("@webiny/di").Abstraction<IPublishEntryRepository>;
+export declare namespace PublishEntryRepository {
+    type Interface = IPublishEntryRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/PublishEntry/abstractions.js

@@ -0,0 +1,27 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * PublishEntry Use Case - Publishes an entry revision.
+ */
+
+export const PublishEntryUseCase = createAbstraction("PublishEntryUseCase");
+
+/**
+ * Payload for before publish event
+ */
+
+/**
+ * Payload for after publish event
+ */
+
+/**
+ * Payload for publish error event
+ */
+
+/**
+ * PublishEntryRepository - Handles storage operations for publishing entries.
+ */
+
+export const PublishEntryRepository = createAbstraction("PublishEntryRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","PublishEntryUseCase","PublishEntryRepository"],"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    EntryValidationError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * PublishEntry Use Case - Publishes an entry revision.\n */\nexport interface IPublishEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IPublishEntryUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    validation: EntryValidationError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IPublishEntryUseCaseErrors[keyof IPublishEntryUseCaseErrors];\n\nexport const PublishEntryUseCase = createAbstraction<IPublishEntryUseCase>(\"PublishEntryUseCase\");\n\nexport namespace PublishEntryUseCase {\n    export type Interface = IPublishEntryUseCase;\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 publish event\n */\nexport interface EntryBeforePublishEventPayload {\n    entry: CmsEntry;\n    original: CmsEntry;\n    model: CmsModel;\n}\n\n/**\n * Payload for after publish event\n */\nexport interface EntryAfterPublishEventPayload {\n    entry: CmsEntry;\n    original: CmsEntry;\n    model: CmsModel;\n}\n\n/**\n * Payload for publish error event\n */\nexport interface EntryPublishErrorEventPayload {\n    entry: CmsEntry;\n    original: CmsEntry;\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * PublishEntryRepository - Handles storage operations for publishing entries.\n */\nexport interface IPublishEntryRepository {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<CmsEntry<T>, RepositoryError>>;\n}\n\nexport interface IPublishEntryRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError = IPublishEntryRepositoryErrors[keyof IPublishEntryRepositoryErrors];\n\nexport const PublishEntryRepository =\n    createAbstraction<IPublishEntryRepository>(\"PublishEntryRepository\");\n\nexport namespace PublishEntryRepository {\n    export type Interface = IPublishEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAS/D;AACA;AACA;;AAiBA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;;AAUjG;AACA;AACA;;AAOA;AACA;AACA;;AAOA;AACA;AACA;;AAQA;AACA;AACA;;AAcA,OAAO,MAAME,sBAAsB,GAC/BF,iBAAiB,CAA0B,wBAAwB,CAAC","ignoreList":[]}

package/features/contentEntry/PublishEntry/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 { EntryAfterPublishEventPayload, EntryBeforePublishEventPayload, EntryPublishErrorEventPayload } from "./abstractions.js";
+/**
+ * Before publish entry event
+ */
+export declare class EntryBeforePublishEvent extends DomainEvent<EntryBeforePublishEventPayload> {
+    eventType: "Cms/Entry/BeforePublish";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforePublishEvent>>;
+}
+export declare const EntryBeforePublishEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforePublishEvent>>;
+export declare namespace EntryBeforePublishEventHandler {
+    type Interface = IEventHandler<EntryBeforePublishEvent>;
+    type Event = EntryBeforePublishEvent;
+}
+/**
+ * After publish entry event
+ */
+export declare class EntryAfterPublishEvent extends DomainEvent<EntryAfterPublishEventPayload> {
+    eventType: "Cms/Entry/AfterPublish";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterPublishEvent>>;
+}
+export declare const EntryAfterPublishEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterPublishEvent>>;
+export declare namespace EntryAfterPublishEventHandler {
+    type Interface = IEventHandler<EntryAfterPublishEvent>;
+    type Event = EntryAfterPublishEvent;
+}
+/**
+ * Publish entry error event
+ */
+export declare class EntryPublishErrorEvent extends DomainEvent<EntryPublishErrorEventPayload> {
+    eventType: "Cms/Entry/PublishError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryPublishErrorEvent>>;
+}
+export declare const EntryPublishErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryPublishErrorEvent>>;
+export declare namespace EntryPublishErrorEventHandler {
+    type Interface = IEventHandler<EntryPublishErrorEvent>;
+    type Event = EntryPublishErrorEvent;
+}

package/features/contentEntry/PublishEntry/events.js

@@ -0,0 +1,34 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+/**
+ * Before publish entry event
+ */
+export class EntryBeforePublishEvent extends DomainEvent {
+  eventType = "Cms/Entry/BeforePublish";
+  getHandlerAbstraction() {
+    return EntryBeforePublishEventHandler;
+  }
+}
+export const EntryBeforePublishEventHandler = createAbstraction("EntryBeforePublishEventHandler");
+/**
+ * After publish entry event
+ */
+export class EntryAfterPublishEvent extends DomainEvent {
+  eventType = "Cms/Entry/AfterPublish";
+  getHandlerAbstraction() {
+    return EntryAfterPublishEventHandler;
+  }
+}
+export const EntryAfterPublishEventHandler = createAbstraction("EntryAfterPublishEventHandler");
+/**
+ * Publish entry error event
+ */
+export class EntryPublishErrorEvent extends DomainEvent {
+  eventType = "Cms/Entry/PublishError";
+  getHandlerAbstraction() {
+    return EntryPublishErrorEventHandler;
+  }
+}
+export const EntryPublishErrorEventHandler = createAbstraction("EntryPublishErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforePublishEvent","eventType","getHandlerAbstraction","EntryBeforePublishEventHandler","EntryAfterPublishEvent","EntryAfterPublishEventHandler","EntryPublishErrorEvent","EntryPublishErrorEventHandler"],"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    EntryAfterPublishEventPayload,\n    EntryBeforePublishEventPayload,\n    EntryPublishErrorEventPayload\n} from \"./abstractions.js\";\n\n/**\n * Before publish entry event\n */\nexport class EntryBeforePublishEvent extends DomainEvent<EntryBeforePublishEventPayload> {\n    eventType = \"Cms/Entry/BeforePublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforePublishEventHandler;\n    }\n}\n\nexport const EntryBeforePublishEventHandler = createAbstraction<\n    IEventHandler<EntryBeforePublishEvent>\n>(\"EntryBeforePublishEventHandler\");\n\nexport namespace EntryBeforePublishEventHandler {\n    export type Interface = IEventHandler<EntryBeforePublishEvent>;\n    export type Event = EntryBeforePublishEvent;\n}\n\n/**\n * After publish entry event\n */\nexport class EntryAfterPublishEvent extends DomainEvent<EntryAfterPublishEventPayload> {\n    eventType = \"Cms/Entry/AfterPublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterPublishEventHandler;\n    }\n}\n\nexport const EntryAfterPublishEventHandler = createAbstraction<\n    IEventHandler<EntryAfterPublishEvent>\n>(\"EntryAfterPublishEventHandler\");\n\nexport namespace EntryAfterPublishEventHandler {\n    export type Interface = IEventHandler<EntryAfterPublishEvent>;\n    export type Event = EntryAfterPublishEvent;\n}\n\n/**\n * Publish entry error event\n */\nexport class EntryPublishErrorEvent extends DomainEvent<EntryPublishErrorEventPayload> {\n    eventType = \"Cms/Entry/PublishError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryPublishErrorEventHandler;\n    }\n}\n\nexport const EntryPublishErrorEventHandler = createAbstraction<\n    IEventHandler<EntryPublishErrorEvent>\n>(\"EntryPublishErrorEventHandler\");\n\nexport namespace EntryPublishErrorEventHandler {\n    export type Interface = IEventHandler<EntryPublishErrorEvent>;\n    export type Event = EntryPublishErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;AAOtE;AACA;AACA;AACA,OAAO,MAAMC,uBAAuB,SAASD,WAAW,CAAiC;EACrFE,SAAS,GAAG,yBAAyB;EAErCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,8BAA8B;EACzC;AACJ;AAEA,OAAO,MAAMA,8BAA8B,GAAGL,iBAAiB,CAE7D,gCAAgC,CAAC;AAOnC;AACA;AACA;AACA,OAAO,MAAMM,sBAAsB,SAASL,WAAW,CAAgC;EACnFE,SAAS,GAAG,wBAAwB;EAEpCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGP,iBAAiB,CAE5D,+BAA+B,CAAC;AAOlC;AACA;AACA;AACA,OAAO,MAAMQ,sBAAsB,SAASP,WAAW,CAAgC;EACnFE,SAAS,GAAG,wBAAwB;EAEpCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGT,iBAAiB,CAE5D,+BAA+B,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/PublishEntry/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","PublishEntryUseCase","PublishEntryRepository","PublishEntryFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { PublishEntryUseCase } from \"./PublishEntryUseCase.js\";\nimport { PublishEntryRepository } from \"./PublishEntryRepository.js\";\n\nexport const PublishEntryFeature = createFeature({\n    name: \"PublishEntry\",\n    register(container) {\n        // Register repository (singleton scope)\n        container.register(PublishEntryRepository).inSingletonScope();\n\n        // Register use case (transient scope)\n        container.register(PublishEntryUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB;AAE/B,OAAO,MAAMC,mBAAmB,GAAGH,aAAa,CAAC;EAC7CI,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,sBAAsB,CAAC,CAACK,gBAAgB,CAAC,CAAC;;IAE7D;IACAD,SAAS,CAACD,QAAQ,CAACJ,mBAAmB,CAAC;EAC3C;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { PublishEntryUseCase, PublishEntryRepository } from "./abstractions.js";
+export { EntryAfterPublishEventHandler, EntryBeforePublishEventHandler } from "./events.js";

package/features/contentEntry/PublishEntry/index.js

@@ -0,0 +1,4 @@
+export { PublishEntryUseCase, PublishEntryRepository } from "./abstractions.js";
+export { EntryAfterPublishEventHandler, EntryBeforePublishEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["PublishEntryUseCase","PublishEntryRepository","EntryAfterPublishEventHandler","EntryBeforePublishEventHandler"],"sources":["index.ts"],"sourcesContent":["export { PublishEntryUseCase, PublishEntryRepository } from \"./abstractions.js\";\nexport { EntryAfterPublishEventHandler, EntryBeforePublishEventHandler } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,mBAAmB,EAAEC,sBAAsB;AACpD,SAASC,6BAA6B,EAAEC,8BAA8B","ignoreList":[]}

package/features/contentEntry/RepublishEntry/RepublishEntryRepository.d.ts

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { RepublishEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import { EntryToStorageTransform } from "../../../legacy/abstractions.js";
+import { EntryFromStorageTransform } from "../../../legacy/abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * RepublishEntryRepository - Handles storage operations for republishing entries.
+ *
+ * Responsibilities:
+ * - Transform entry to storage format
+ * - Update the entry in storage
+ * - Publish the entry in storage
+ * - Transform result back from storage format
+ * - Handle storage errors
+ */
+declare class RepublishEntryRepositoryImpl 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 RepublishEntryRepository: import("@webiny/di").Implementation<typeof RepublishEntryRepositoryImpl>;
+export {};

package/features/contentEntry/RepublishEntry/RepublishEntryRepository.js

@@ -0,0 +1,56 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { RepublishEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryToStorageTransform } from "../../../legacy/abstractions.js";
+import { EntryFromStorageTransform } from "../../../legacy/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * RepublishEntryRepository - Handles storage operations for republishing entries.
+ *
+ * Responsibilities:
+ * - Transform entry to storage format
+ * - Update the entry in storage
+ * - Publish the entry in storage
+ * - Transform result back from storage format
+ * - Handle storage errors
+ */
+class RepublishEntryRepositoryImpl {
+  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);
+
+      // First update the entry
+      await this.storageOperations.entries.update(model, {
+        entry,
+        storageEntry
+      });
+
+      // Then publish it
+      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 RepublishEntryRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: RepublishEntryRepositoryImpl,
+  dependencies: [EntryToStorageTransform, EntryFromStorageTransform, StorageOperations]
+});
+
+//# sourceMappingURL=RepublishEntryRepository.js.map

package/features/contentEntry/RepublishEntry/RepublishEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","RepublishEntryRepository","RepositoryAbstraction","StorageOperations","EntryToStorageTransform","EntryFromStorageTransform","EntryPersistenceError","RepublishEntryRepositoryImpl","constructor","entryToStorageTransform","entryFromStorageTransform","storageOperations","execute","model","entry","storageEntry","entries","update","result","publish","transformedEntry","ok","error","fail","abstraction","implementation","dependencies"],"sources":["RepublishEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { RepublishEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { EntryToStorageTransform } from \"~/legacy/abstractions.js\";\nimport { EntryFromStorageTransform } from \"~/legacy/abstractions.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * RepublishEntryRepository - Handles storage operations for republishing entries.\n *\n * Responsibilities:\n * - Transform entry to storage format\n * - Update the entry in storage\n * - Publish the entry in storage\n * - Transform result back from storage format\n * - Handle storage errors\n */\nclass RepublishEntryRepositoryImpl 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<T>(model, entry);\n\n            // First update the entry\n            await this.storageOperations.entries.update(model, {\n                entry,\n                storageEntry\n            });\n\n            // Then publish it\n            const result = await this.storageOperations.entries.publish<T>(model, {\n                entry,\n                storageEntry\n            });\n\n            // Transform result back from storage format\n            const transformedEntry = await this.entryFromStorageTransform<T>(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 RepublishEntryRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: RepublishEntryRepositoryImpl,\n    dependencies: [EntryToStorageTransform, EntryFromStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,wBAAwB,IAAIC,qBAAqB;AAC1D,SAASC,iBAAiB;AAC1B,SAASC,uBAAuB;AAChC,SAASC,yBAAyB;AAElC,SAASC,qBAAqB;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,4BAA4B,CAA4C;EACnEC,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,CAAII,KAAK,EAAEC,KAAK,CAAC;;MAExE;MACA,MAAM,IAAI,CAACH,iBAAiB,CAACK,OAAO,CAACC,MAAM,CAACJ,KAAK,EAAE;QAC/CC,KAAK;QACLC;MACJ,CAAC,CAAC;;MAEF;MACA,MAAMG,MAAM,GAAG,MAAM,IAAI,CAACP,iBAAiB,CAACK,OAAO,CAACG,OAAO,CAAIN,KAAK,EAAE;QAClEC,KAAK;QACLC;MACJ,CAAC,CAAC;;MAEF;MACA,MAAMK,gBAAgB,GAAG,MAAM,IAAI,CAACV,yBAAyB,CAAIG,KAAK,EAAEK,MAAM,CAAC;MAE/E,OAAOnB,MAAM,CAACsB,EAAE,CAACD,gBAAgB,CAAC;IACtC,CAAC,CAAC,OAAOE,KAAK,EAAE;MACZ,OAAOvB,MAAM,CAACwB,IAAI,CAAC,IAAIjB,qBAAqB,CAACgB,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMrB,wBAAwB,GAAGD,oBAAoB,CAAC;EACzDwB,WAAW,EAAEtB,qBAAqB;EAClCuB,cAAc,EAAElB,4BAA4B;EAC5CmB,YAAY,EAAE,CAACtB,uBAAuB,EAAEC,yBAAyB,EAAEF,iBAAiB;AACxF,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/RepublishEntry/RepublishEntryUseCase.d.ts

@@ -0,0 +1,31 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { RepublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { RepublishEntryRepository } 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";
+import { CmsContext } from "../../../features/shared/abstractions.js";
+/**
+ * RepublishEntryUseCase - Orchestrates republishing an entry.
+ *
+ * Responsibilities:
+ * - Apply access control (both write and publish permissions)
+ * - Get the entry to republish
+ * - Prepare entry data with updated timestamps
+ * - Publish domain events
+ * - Delegate to repository for storage operations (update + publish)
+ */
+declare class RepublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private getRevisionById;
+    private identityContext;
+    private eventPublisher;
+    private cmsContext;
+    constructor(repository: RepublishEntryRepository.Interface, accessControl: AccessControl.Interface, getRevisionById: GetRevisionByIdUseCase.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 RepublishEntryUseCase: import("@webiny/di").Implementation<typeof RepublishEntryUseCaseImpl>;
+export {};

package/features/contentEntry/RepublishEntry/RepublishEntryUseCase.js

@@ -0,0 +1,113 @@
+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 { RepublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { RepublishEntryRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../GetRevisionById/index.js";
+import { EntryBeforeRepublishEvent, EntryAfterRepublishEvent, EntryRepublishErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+import { createRepublishEntryData } from "../../../crud/contentEntry/entryDataFactories/index.js";
+import { CmsContext } from "../../shared/abstractions.js";
+
+/**
+ * RepublishEntryUseCase - Orchestrates republishing an entry.
+ *
+ * Responsibilities:
+ * - Apply access control (both write and publish permissions)
+ * - Get the entry to republish
+ * - Prepare entry data with updated timestamps
+ * - Publish domain events
+ * - Delegate to repository for storage operations (update + publish)
+ */
+class RepublishEntryUseCaseImpl {
+  constructor(repository, accessControl, getRevisionById, identityContext, eventPublisher, cmsContext) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+    this.getRevisionById = getRevisionById;
+    this.identityContext = identityContext;
+    this.eventPublisher = eventPublisher;
+    this.cmsContext = cmsContext;
+  }
+  async execute(model, id) {
+    // Check access control (write and publish)
+    const canAccess = await this.accessControl.canAccessEntry({
+      model,
+      rwd: "w",
+      pw: "p"
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Get the entry to republish
+    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,
+      rwd: "w",
+      pw: "p"
+    });
+    if (!canAccessEntry) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Prepare entry data for republishing
+    const {
+      entry
+    } = await createRepublishEntryData({
+      context: this.cmsContext,
+      model,
+      originalEntry,
+      getIdentity: () => this.identityContext.getIdentity()
+    });
+    try {
+      // Publish before event
+      await this.eventPublisher.publish(new EntryBeforeRepublishEvent({
+        entry,
+        model
+      }));
+
+      // Delegate to repository (update + publish)
+      const repositoryResult = await this.repository.execute(model, entry);
+      if (repositoryResult.isFail()) {
+        await this.eventPublisher.publish(new EntryRepublishErrorEvent({
+          entry,
+          model,
+          error: repositoryResult.error
+        }));
+        return Result.fail(repositoryResult.error);
+      }
+      const publishedEntry = repositoryResult.value;
+
+      // Publish after event
+      await this.eventPublisher.publish(new EntryAfterRepublishEvent({
+        entry: publishedEntry,
+        model
+      }));
+      return Result.ok(entry);
+    } catch (error) {
+      await this.eventPublisher.publish(new EntryRepublishErrorEvent({
+        entry,
+        model,
+        error: error
+      }));
+      return Result.fail(error);
+    }
+  }
+}
+export const RepublishEntryUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: RepublishEntryUseCaseImpl,
+  dependencies: [RepublishEntryRepository, AccessControl, GetRevisionByIdUseCase, IdentityContext, EventPublisher, CmsContext]
+});
+
+//# sourceMappingURL=RepublishEntryUseCase.js.map

package/features/contentEntry/RepublishEntry/RepublishEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","IdentityContext","EventPublisher","RepublishEntryUseCase","UseCaseAbstraction","RepublishEntryRepository","AccessControl","GetRevisionByIdUseCase","EntryBeforeRepublishEvent","EntryAfterRepublishEvent","EntryRepublishErrorEvent","EntryNotAuthorizedError","EntryNotFoundError","createRepublishEntryData","CmsContext","RepublishEntryUseCaseImpl","constructor","repository","accessControl","getRevisionById","identityContext","eventPublisher","cmsContext","execute","model","id","canAccess","canAccessEntry","rwd","pw","fail","fromModel","result","isFail","originalEntry","value","entry","context","getIdentity","publish","repositoryResult","error","publishedEntry","ok","abstraction","implementation","dependencies"],"sources":["RepublishEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport { RepublishEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { RepublishEntryRepository } 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 {\n    EntryBeforeRepublishEvent,\n    EntryAfterRepublishEvent,\n    EntryRepublishErrorEvent\n} from \"./events.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\nimport { createRepublishEntryData } from \"~/crud/contentEntry/entryDataFactories/index.js\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\n\n/**\n * RepublishEntryUseCase - Orchestrates republishing an entry.\n *\n * Responsibilities:\n * - Apply access control (both write and publish permissions)\n * - Get the entry to republish\n * - Prepare entry data with updated timestamps\n * - Publish domain events\n * - Delegate to repository for storage operations (update + publish)\n */\nclass RepublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: RepublishEntryRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private cmsContext: CmsContext.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string\n    ): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>> {\n        // Check access control (write and publish)\n        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"w\", pw: \"p\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Get the entry to republish\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 originalEntry = result.value;\n\n        // Check access control on the specific entry\n        const canAccessEntry = await this.accessControl.canAccessEntry({\n            model,\n            entry: originalEntry,\n            rwd: \"w\",\n            pw: \"p\"\n        });\n\n        if (!canAccessEntry) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Prepare entry data for republishing\n        const { entry } = await createRepublishEntryData<T>({\n            context: this.cmsContext,\n            model,\n            originalEntry,\n            getIdentity: () => this.identityContext.getIdentity()\n        });\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryBeforeRepublishEvent({\n                    entry,\n                    model\n                })\n            );\n\n            // Delegate to repository (update + publish)\n            const repositoryResult = await this.repository.execute<T>(model, entry);\n\n            if (repositoryResult.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryRepublishErrorEvent({\n                        entry,\n                        model,\n                        error: repositoryResult.error\n                    })\n                );\n                return Result.fail(repositoryResult.error);\n            }\n\n            const publishedEntry = repositoryResult.value;\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterRepublishEvent({\n                    entry: publishedEntry,\n                    model\n                })\n            );\n\n            return Result.ok(entry);\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryRepublishErrorEvent({\n                    entry,\n                    model,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const RepublishEntryUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: RepublishEntryUseCaseImpl,\n    dependencies: [\n        RepublishEntryRepository,\n        AccessControl,\n        GetRevisionByIdUseCase,\n        IdentityContext,\n        EventPublisher,\n        CmsContext\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,60 @@
+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";
+/**
+ * RepublishEntry Use Case - Republishes an already published entry.
+ * This updates the entry and publishes it again.
+ */
+export interface IRepublishEntryUseCase {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string): Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+export interface IRepublishEntryUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    notFound: EntryNotFoundError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IRepublishEntryUseCaseErrors[keyof IRepublishEntryUseCaseErrors];
+export declare const RepublishEntryUseCase: import("@webiny/di").Abstraction<IRepublishEntryUseCase>;
+export declare namespace RepublishEntryUseCase {
+    type Interface = IRepublishEntryUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+/**
+ * Payload for before republish event
+ */
+export interface EntryBeforeRepublishEventPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+}
+/**
+ * Payload for after republish event
+ */
+export interface EntryAfterRepublishEventPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+}
+/**
+ * Payload for republish error event
+ */
+export interface EntryRepublishErrorEventPayload {
+    entry: CmsEntry;
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * RepublishEntryRepository - Handles storage operations for republishing entries.
+ */
+export interface IRepublishEntryRepository {
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, entry: CmsEntry<T>): Promise<Result<CmsEntry<T>, RepositoryError>>;
+}
+export interface IRepublishEntryRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IRepublishEntryRepositoryErrors[keyof IRepublishEntryRepositoryErrors];
+export declare const RepublishEntryRepository: import("@webiny/di").Abstraction<IRepublishEntryRepository>;
+export declare namespace RepublishEntryRepository {
+    type Interface = IRepublishEntryRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/RepublishEntry/abstractions.js

@@ -0,0 +1,28 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * RepublishEntry Use Case - Republishes an already published entry.
+ * This updates the entry and publishes it again.
+ */
+
+export const RepublishEntryUseCase = createAbstraction("RepublishEntryUseCase");
+
+/**
+ * Payload for before republish event
+ */
+
+/**
+ * Payload for after republish event
+ */
+
+/**
+ * Payload for republish error event
+ */
+
+/**
+ * RepublishEntryRepository - Handles storage operations for republishing entries.
+ */
+
+export const RepublishEntryRepository = createAbstraction("RepublishEntryRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","RepublishEntryUseCase","RepublishEntryRepository"],"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 * RepublishEntry Use Case - Republishes an already published entry.\n * This updates the entry and publishes it again.\n */\nexport interface IRepublishEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IRepublishEntryUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IRepublishEntryUseCaseErrors[keyof IRepublishEntryUseCaseErrors];\n\nexport const RepublishEntryUseCase =\n    createAbstraction<IRepublishEntryUseCase>(\"RepublishEntryUseCase\");\n\nexport namespace RepublishEntryUseCase {\n    export type Interface = IRepublishEntryUseCase;\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 republish event\n */\nexport interface EntryBeforeRepublishEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n}\n\n/**\n * Payload for after republish event\n */\nexport interface EntryAfterRepublishEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n}\n\n/**\n * Payload for republish error event\n */\nexport interface EntryRepublishErrorEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * RepublishEntryRepository - Handles storage operations for republishing entries.\n */\nexport interface IRepublishEntryRepository {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<CmsEntry<T>, RepositoryError>>;\n}\n\nexport interface IRepublishEntryRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError = IRepublishEntryRepositoryErrors[keyof IRepublishEntryRepositoryErrors];\n\nexport const RepublishEntryRepository = createAbstraction<IRepublishEntryRepository>(\n    \"RepublishEntryRepository\"\n);\n\nexport namespace RepublishEntryRepository {\n    export type Interface = IRepublishEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAQ/D;AACA;AACA;AACA;;AAgBA,OAAO,MAAMC,qBAAqB,GAC9BD,iBAAiB,CAAyB,uBAAuB,CAAC;;AAUtE;AACA;AACA;;AAMA;AACA;AACA;;AAMA;AACA;AACA;;AAOA;AACA;AACA;;AAcA,OAAO,MAAME,wBAAwB,GAAGF,iBAAiB,CACrD,0BACJ,CAAC","ignoreList":[]}