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

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,41 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { RepublishEntryRepository } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryFromStorageTransform, EntryToStorageTransform } from "../../../legacy/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+class RepublishEntryRepositoryImpl {
+    constructor(entryToStorageTransform, entryFromStorageTransform, storageOperations){
+        this.entryToStorageTransform = entryToStorageTransform;
+        this.entryFromStorageTransform = entryFromStorageTransform;
+        this.storageOperations = storageOperations;
+    }
+    async execute(model, entry) {
+        try {
+            const storageEntry = await this.entryToStorageTransform(model, entry);
+            await this.storageOperations.entries.update(model, {
+                entry,
+                storageEntry
+            });
+            const result = await this.storageOperations.entries.publish(model, {
+                entry,
+                storageEntry
+            });
+            const transformedEntry = await this.entryFromStorageTransform(model, result);
+            return Result.ok(transformedEntry);
+        } catch (error) {
+            return Result.fail(new EntryPersistenceError(error));
+        }
+    }
+}
+const RepublishEntryRepository_RepublishEntryRepository = createImplementation({
+    abstraction: RepublishEntryRepository,
+    implementation: RepublishEntryRepositoryImpl,
+    dependencies: [
+        EntryToStorageTransform,
+        EntryFromStorageTransform,
+        StorageOperations
+    ]
+});
+export { RepublishEntryRepository_RepublishEntryRepository as RepublishEntryRepository };
+
+//# sourceMappingURL=RepublishEntryRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RepublishEntry/RepublishEntryRepository.js","sources":["../../../../src/features/contentEntry/RepublishEntry/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"],"names":["RepublishEntryRepositoryImpl","entryToStorageTransform","entryFromStorageTransform","storageOperations","model","entry","storageEntry","result","transformedEntry","Result","error","EntryPersistenceError","RepublishEntryRepository","createImplementation","RepositoryAbstraction","EntryToStorageTransform","EntryFromStorageTransform","StorageOperations"],"mappings":";;;;;AAmBA,MAAMA;IACF,YACYC,uBAA0D,EAC1DC,yBAA8D,EAC9DC,iBAA8C,CACxD;aAHUF,uBAAuB,GAAvBA;aACAC,yBAAyB,GAAzBA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAa,QACTC,KAAe,EACfC,KAAkB,EACuC;QACzD,IAAI;YAEA,MAAMC,eAAe,MAAM,IAAI,CAAC,uBAAuB,CAAIF,OAAOC;YAGlE,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAACD,OAAO;gBAC/CC;gBACAC;YACJ;YAGA,MAAMC,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAIH,OAAO;gBAClEC;gBACAC;YACJ;YAGA,MAAME,mBAAmB,MAAM,IAAI,CAAC,yBAAyB,CAAIJ,OAAOG;YAExE,OAAOE,OAAO,EAAE,CAACD;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,sBAAsBD;QACjD;IACJ;AACJ;AAEO,MAAME,oDAA2BC,qBAAqB;IACzD,aAAaC;IACb,gBAAgBd;IAChB,cAAc;QAACe;QAAyBC;QAA2BC;KAAkB;AACzF"}

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

@@ -0,0 +1,19 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+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 { CreateRepublishEntryDataFactory } from "../../../features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/index.js";
+declare class RepublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private getRevisionById;
+    private eventPublisher;
+    private createRepublishEntryDataFactory;
+    constructor(repository: RepublishEntryRepository.Interface, accessControl: AccessControl.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, eventPublisher: EventPublisher.Interface, createRepublishEntryDataFactory: CreateRepublishEntryDataFactory.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,78 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { RepublishEntryRepository, RepublishEntryUseCase } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { GetRevisionByIdUseCase } from "../GetRevisionById/index.js";
+import { EntryAfterRepublishEvent, EntryBeforeRepublishEvent, EntryRepublishErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError, EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+import { CreateRepublishEntryDataFactory } from "../entryDataFactories/CreateRepublishEntryDataFactory/index.js";
+class RepublishEntryUseCaseImpl {
+    constructor(repository, accessControl, getRevisionById, eventPublisher, createRepublishEntryDataFactory){
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.getRevisionById = getRevisionById;
+        this.eventPublisher = eventPublisher;
+        this.createRepublishEntryDataFactory = createRepublishEntryDataFactory;
+    }
+    async execute(model, id) {
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            rwd: "w",
+            pw: "p"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const result = await this.getRevisionById.execute(model, id);
+        if (result.isFail()) return Result.fail(new EntryNotFoundError(id));
+        const originalEntry = result.value;
+        const canAccessEntry = await this.accessControl.canAccessEntry({
+            model,
+            entry: originalEntry,
+            rwd: "w",
+            pw: "p"
+        });
+        if (!canAccessEntry) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const { entry } = await this.createRepublishEntryDataFactory.create(model, originalEntry);
+        try {
+            await this.eventPublisher.publish(new EntryBeforeRepublishEvent({
+                entry,
+                model
+            }));
+            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;
+            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);
+        }
+    }
+}
+const RepublishEntryUseCase_RepublishEntryUseCase = createImplementation({
+    abstraction: RepublishEntryUseCase,
+    implementation: RepublishEntryUseCaseImpl,
+    dependencies: [
+        RepublishEntryRepository,
+        AccessControl,
+        GetRevisionByIdUseCase,
+        EventPublisher,
+        CreateRepublishEntryDataFactory
+    ]
+});
+export { RepublishEntryUseCase_RepublishEntryUseCase as RepublishEntryUseCase };
+
+//# sourceMappingURL=RepublishEntryUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RepublishEntry/RepublishEntryUseCase.js","sources":["../../../../src/features/contentEntry/RepublishEntry/RepublishEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { 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 { CreateRepublishEntryDataFactory } from \"~/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/index.js\";\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 eventPublisher: EventPublisher.Interface,\n        private createRepublishEntryDataFactory: CreateRepublishEntryDataFactory.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        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"w\", pw: \"p\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\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        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        const { entry } = await this.createRepublishEntryDataFactory.create<T>(\n            model,\n            originalEntry\n        );\n\n        try {\n            await this.eventPublisher.publish(\n                new EntryBeforeRepublishEvent({\n                    entry,\n                    model\n                })\n            );\n\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            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        EventPublisher,\n        CreateRepublishEntryDataFactory\n    ]\n});\n"],"names":["RepublishEntryUseCaseImpl","repository","accessControl","getRevisionById","eventPublisher","createRepublishEntryDataFactory","model","id","canAccess","Result","EntryNotAuthorizedError","result","EntryNotFoundError","originalEntry","canAccessEntry","entry","EntryBeforeRepublishEvent","repositoryResult","EntryRepublishErrorEvent","publishedEntry","EntryAfterRepublishEvent","error","RepublishEntryUseCase","createImplementation","UseCaseAbstraction","RepublishEntryRepository","AccessControl","GetRevisionByIdUseCase","EventPublisher","CreateRepublishEntryDataFactory"],"mappings":";;;;;;;;AAiBA,MAAMA;IACF,YACYC,UAA8C,EAC9CC,aAAsC,EACtCC,eAAiD,EACjDC,cAAwC,EACxCC,+BAA0E,CACpF;aALUJ,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,cAAc,GAAdA;aACAC,+BAA+B,GAA/BA;IACT;IAEH,MAAa,QACTC,KAAe,EACfC,EAAU,EAC4C;QACtD,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEF;YAAO,KAAK;YAAK,IAAI;QAAI;QACrF,IAAI,CAACE,WACD,OAAOC,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAGzD,MAAMK,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAIL,OAAOC;QAE5D,IAAII,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAAC,IAAIG,mBAAmBL;QAG9C,MAAMM,gBAAgBF,OAAO,KAAK;QAElC,MAAMG,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAC3DR;YACA,OAAOO;YACP,KAAK;YACL,IAAI;QACR;QAEA,IAAI,CAACC,gBACD,OAAOL,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAGzD,MAAM,EAAES,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,MAAM,CAC/DT,OACAO;QAGJ,IAAI;YACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,0BAA0B;gBAC1BD;gBACAT;YACJ;YAGJ,MAAMW,mBAAmB,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAIX,OAAOS;YAEjE,IAAIE,iBAAiB,MAAM,IAAI;gBAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,yBAAyB;oBACzBH;oBACAT;oBACA,OAAOW,iBAAiB,KAAK;gBACjC;gBAEJ,OAAOR,OAAO,IAAI,CAACQ,iBAAiB,KAAK;YAC7C;YAEA,MAAME,iBAAiBF,iBAAiB,KAAK;YAE7C,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,yBAAyB;gBACzB,OAAOD;gBACPb;YACJ;YAGJ,OAAOG,OAAO,EAAE,CAACM;QACrB,EAAE,OAAOM,OAAO;YACZ,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIH,yBAAyB;gBACzBH;gBACAT;gBACA,OAAOe;YACX;YAEJ,OAAOZ,OAAO,IAAI,CAACY;QACvB;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,qBAAqB;IACtD,aAAaC;IACb,gBAAgBxB;IAChB,cAAc;QACVyB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,61 @@
+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];
+/** Republish a content entry. */
+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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const RepublishEntryUseCase = createAbstraction("RepublishEntryUseCase");
+const RepublishEntryRepository = createAbstraction("RepublishEntryRepository");
+export { RepublishEntryRepository, RepublishEntryUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RepublishEntry/abstractions.js","sources":["../../../../src/features/contentEntry/RepublishEntry/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\n/** Republish a content entry. */\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"],"names":["RepublishEntryUseCase","createAbstraction","RepublishEntryRepository"],"mappings":";AA4BO,MAAMA,wBACTC,kBAA0C;AAmDvC,MAAMC,2BAA2BD,kBACpC"}

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

@@ -0,0 +1,41 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { EntryAfterRepublishEventPayload, EntryBeforeRepublishEventPayload, EntryRepublishErrorEventPayload } from "./abstractions.js";
+/**
+ * Before republish entry event
+ */
+export declare class EntryBeforeRepublishEvent extends DomainEvent<EntryBeforeRepublishEventPayload> {
+    eventType: "Cms/Entry/BeforeRepublish";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeRepublishEvent>>;
+}
+/** Hook into entry lifecycle before an entry is republished. */
+export declare const EntryBeforeRepublishEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeRepublishEvent>>;
+export declare namespace EntryBeforeRepublishEventHandler {
+    type Interface = IEventHandler<EntryBeforeRepublishEvent>;
+    type Event = EntryBeforeRepublishEvent;
+}
+/**
+ * After republish entry event
+ */
+export declare class EntryAfterRepublishEvent extends DomainEvent<EntryAfterRepublishEventPayload> {
+    eventType: "Cms/Entry/AfterRepublish";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterRepublishEvent>>;
+}
+/** Hook into entry lifecycle after an entry is republished. */
+export declare const EntryAfterRepublishEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterRepublishEvent>>;
+export declare namespace EntryAfterRepublishEventHandler {
+    type Interface = IEventHandler<EntryAfterRepublishEvent>;
+    type Event = EntryAfterRepublishEvent;
+}
+/**
+ * Republish entry error event
+ */
+export declare class EntryRepublishErrorEvent extends DomainEvent<EntryRepublishErrorEventPayload> {
+    eventType: "Cms/Entry/RepublishError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryRepublishErrorEvent>>;
+}
+export declare const EntryRepublishErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryRepublishErrorEvent>>;
+export declare namespace EntryRepublishErrorEventHandler {
+    type Interface = IEventHandler<EntryRepublishErrorEvent>;
+    type Event = EntryRepublishErrorEvent;
+}

package/features/contentEntry/RepublishEntry/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class EntryBeforeRepublishEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeRepublishEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/BeforeRepublish";
+    }
+}
+const EntryBeforeRepublishEventHandler = createAbstraction("EntryBeforeRepublishEventHandler");
+class EntryAfterRepublishEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterRepublishEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/AfterRepublish";
+    }
+}
+const EntryAfterRepublishEventHandler = createAbstraction("EntryAfterRepublishEventHandler");
+class EntryRepublishErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryRepublishErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/RepublishError";
+    }
+}
+const EntryRepublishErrorEventHandler = createAbstraction("EntryRepublishErrorEventHandler");
+export { EntryAfterRepublishEvent, EntryAfterRepublishEventHandler, EntryBeforeRepublishEvent, EntryBeforeRepublishEventHandler, EntryRepublishErrorEvent, EntryRepublishErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RepublishEntry/events.js","sources":["../../../../src/features/contentEntry/RepublishEntry/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type {\n    EntryAfterRepublishEventPayload,\n    EntryBeforeRepublishEventPayload,\n    EntryRepublishErrorEventPayload\n} from \"./abstractions.js\";\n\n/**\n * Before republish entry event\n */\nexport class EntryBeforeRepublishEvent extends DomainEvent<EntryBeforeRepublishEventPayload> {\n    eventType = \"Cms/Entry/BeforeRepublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeRepublishEventHandler;\n    }\n}\n\n/** Hook into entry lifecycle before an entry is republished. */\nexport const EntryBeforeRepublishEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeRepublishEvent>\n>(\"EntryBeforeRepublishEventHandler\");\n\nexport namespace EntryBeforeRepublishEventHandler {\n    export type Interface = IEventHandler<EntryBeforeRepublishEvent>;\n    export type Event = EntryBeforeRepublishEvent;\n}\n\n/**\n * After republish entry event\n */\nexport class EntryAfterRepublishEvent extends DomainEvent<EntryAfterRepublishEventPayload> {\n    eventType = \"Cms/Entry/AfterRepublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterRepublishEventHandler;\n    }\n}\n\n/** Hook into entry lifecycle after an entry is republished. */\nexport const EntryAfterRepublishEventHandler = createAbstraction<\n    IEventHandler<EntryAfterRepublishEvent>\n>(\"EntryAfterRepublishEventHandler\");\n\nexport namespace EntryAfterRepublishEventHandler {\n    export type Interface = IEventHandler<EntryAfterRepublishEvent>;\n    export type Event = EntryAfterRepublishEvent;\n}\n\n/**\n * Republish entry error event\n */\nexport class EntryRepublishErrorEvent extends DomainEvent<EntryRepublishErrorEventPayload> {\n    eventType = \"Cms/Entry/RepublishError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryRepublishErrorEventHandler;\n    }\n}\n\nexport const EntryRepublishErrorEventHandler = createAbstraction<\n    IEventHandler<EntryRepublishErrorEvent>\n>(\"EntryRepublishErrorEventHandler\");\n\nexport namespace EntryRepublishErrorEventHandler {\n    export type Interface = IEventHandler<EntryRepublishErrorEvent>;\n    export type Event = EntryRepublishErrorEvent;\n}\n"],"names":["EntryBeforeRepublishEvent","DomainEvent","EntryBeforeRepublishEventHandler","createAbstraction","EntryAfterRepublishEvent","EntryAfterRepublishEventHandler","EntryRepublishErrorEvent","EntryRepublishErrorEventHandler"],"mappings":";;AAYO,MAAMA,kCAAkCC;IAG3C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,mCAAmCC,kBAE9C;AAUK,MAAMC,iCAAiCH;IAG1C,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,kCAAkCF,kBAE7C;AAUK,MAAMG,iCAAiCL;IAG1C,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,kCAAkCJ,kBAE7C"}

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

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

package/features/contentEntry/RepublishEntry/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RepublishEntry/feature.js","sources":["../../../../src/features/contentEntry/RepublishEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { RepublishEntryUseCase } from \"./RepublishEntryUseCase.js\";\nimport { RepublishEntryRepository } from \"./RepublishEntryRepository.js\";\n\nexport const RepublishEntryFeature = createFeature({\n    name: \"RepublishEntry\",\n    register(container) {\n        // Register repository (singleton scope)\n        container.register(RepublishEntryRepository).inSingletonScope();\n\n        // Register use case (transient scope)\n        container.register(RepublishEntryUseCase);\n    }\n});\n"],"names":["RepublishEntryFeature","createFeature","container","RepublishEntryRepository","RepublishEntryUseCase"],"mappings":";;;AAIO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC,0BAA0B,gBAAgB;QAG7DD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

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

@@ -0,0 +1,2 @@
+export { RepublishEntryRepository, RepublishEntryUseCase } from "./abstractions.js";
+export { EntryAfterRepublishEventHandler, EntryBeforeRepublishEventHandler } from "./events.js";

package/features/contentEntry/RepublishEntry/index.js

@@ -0,0 +1,2 @@
+export { RepublishEntryRepository, RepublishEntryUseCase } from "./abstractions.js";
+export { EntryAfterRepublishEventHandler, EntryBeforeRepublishEventHandler } from "./events.js";

package/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinRepository.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "@webiny/feature/api";
+import { RestoreEntryFromBinRepository 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";
+/**
+ * RestoreEntryFromBinRepository - Handles storage operations for restoring entries from bin.
+ *
+ * Responsibilities:
+ * - Transform entry to storage format
+ * - Call storage operation to restore entry
+ * - Transform result back from storage format
+ * - Handle storage errors
+ */
+declare class RestoreEntryFromBinRepositoryImpl 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 RestoreEntryFromBinRepository: import("@webiny/di").Implementation<typeof RestoreEntryFromBinRepositoryImpl>;
+export {};

package/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinRepository.js

@@ -0,0 +1,37 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { RestoreEntryFromBinRepository } from "./abstractions.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryFromStorageTransform, EntryToStorageTransform } from "../../../legacy/abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+class RestoreEntryFromBinRepositoryImpl {
+    constructor(entryToStorageTransform, entryFromStorageTransform, storageOperations){
+        this.entryToStorageTransform = entryToStorageTransform;
+        this.entryFromStorageTransform = entryFromStorageTransform;
+        this.storageOperations = storageOperations;
+    }
+    async execute(model, entry) {
+        try {
+            const storageEntry = await this.entryToStorageTransform(model, entry);
+            const result = await this.storageOperations.entries.restoreFromBin(model, {
+                entry,
+                storageEntry
+            });
+            const transformedEntry = await this.entryFromStorageTransform(model, result);
+            return Result.ok(transformedEntry);
+        } catch (error) {
+            return Result.fail(new EntryPersistenceError(error));
+        }
+    }
+}
+const RestoreEntryFromBinRepository_RestoreEntryFromBinRepository = createImplementation({
+    abstraction: RestoreEntryFromBinRepository,
+    implementation: RestoreEntryFromBinRepositoryImpl,
+    dependencies: [
+        EntryToStorageTransform,
+        EntryFromStorageTransform,
+        StorageOperations
+    ]
+});
+export { RestoreEntryFromBinRepository_RestoreEntryFromBinRepository as RestoreEntryFromBinRepository };
+
+//# sourceMappingURL=RestoreEntryFromBinRepository.js.map

package/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinRepository.js","sources":["../../../../src/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinRepository.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport { RestoreEntryFromBinRepository 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 * RestoreEntryFromBinRepository - Handles storage operations for restoring entries from bin.\n *\n * Responsibilities:\n * - Transform entry to storage format\n * - Call storage operation to restore entry\n * - Transform result back from storage format\n * - Handle storage errors\n */\nclass RestoreEntryFromBinRepositoryImpl 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            // Call storage operation\n            const result = await this.storageOperations.entries.restoreFromBin<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 RestoreEntryFromBinRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: RestoreEntryFromBinRepositoryImpl,\n    dependencies: [EntryToStorageTransform, EntryFromStorageTransform, StorageOperations]\n});\n"],"names":["RestoreEntryFromBinRepositoryImpl","entryToStorageTransform","entryFromStorageTransform","storageOperations","model","entry","storageEntry","result","transformedEntry","Result","error","EntryPersistenceError","RestoreEntryFromBinRepository","createImplementation","RepositoryAbstraction","EntryToStorageTransform","EntryFromStorageTransform","StorageOperations"],"mappings":";;;;;AAgBA,MAAMA;IACF,YACYC,uBAA0D,EAC1DC,yBAA8D,EAC9DC,iBAA8C,CACxD;aAHUF,uBAAuB,GAAvBA;aACAC,yBAAyB,GAAzBA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAa,QACTC,KAAe,EACfC,KAAkB,EACuC;QACzD,IAAI;YAEA,MAAMC,eAAe,MAAM,IAAI,CAAC,uBAAuB,CAAIF,OAAOC;YAGlE,MAAME,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,cAAc,CAAIH,OAAO;gBACzEC;gBACAC;YACJ;YAGA,MAAME,mBAAmB,MAAM,IAAI,CAAC,yBAAyB,CAAIJ,OAAOG;YAExE,OAAOE,OAAO,EAAE,CAACD;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,sBAAsBD;QACjD;IACJ;AACJ;AAEO,MAAME,8DAAgCC,qBAAqB;IAC9D,aAAaC;IACb,gBAAgBd;IAChB,cAAc;QAACe;QAAyBC;QAA2BC;KAAkB;AACzF"}

package/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinUseCase.d.ts

@@ -0,0 +1,31 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { RestoreEntryFromBinUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { RestoreEntryFromBinRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { GetLatestDeletedRevisionByEntryIdUseCase } from "../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * RestoreEntryFromBinUseCase - Orchestrates restoring a soft-deleted entry from the bin.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Get the deleted entry to restore by ID
+ * - Clear deletion flags (wbyDeleted = false)
+ * - Restore entry to its original folder
+ * - Update restoration metadata
+ * - Publish domain events
+ * - Delegate to repository for storage operations
+ */
+declare class RestoreEntryFromBinUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    private getDeletedEntry;
+    private identityContext;
+    private eventPublisher;
+    constructor(repository: RestoreEntryFromBinRepository.Interface, accessControl: AccessControl.Interface, getDeletedEntry: GetLatestDeletedRevisionByEntryIdUseCase.Interface, identityContext: IdentityContext.Interface, eventPublisher: EventPublisher.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+}
+export declare const RestoreEntryFromBinUseCase: import("@webiny/di").Implementation<typeof RestoreEntryFromBinUseCaseImpl>;
+export {};

package/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinUseCase.js

@@ -0,0 +1,93 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { RestoreEntryFromBinRepository, RestoreEntryFromBinUseCase } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { GetLatestDeletedRevisionByEntryIdUseCase } from "../GetLatestRevisionByEntryId/index.js";
+import { EntryAfterRestoreFromBinEvent, EntryBeforeRestoreFromBinEvent, EntryRestoreFromBinErrorEvent } from "./events.js";
+import { EntryNotAuthorizedError, EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+import { getDate } from "../../../utils/date.js";
+import { getIdentity } from "../../../utils/identity.js";
+class RestoreEntryFromBinUseCaseImpl {
+    constructor(repository, accessControl, getDeletedEntry, identityContext, eventPublisher){
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.getDeletedEntry = getDeletedEntry;
+        this.identityContext = identityContext;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(model, id) {
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            rwd: "w"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const getResult = await this.getDeletedEntry.execute(model, {
+            id
+        });
+        if (getResult.isFail()) return Result.fail(new EntryNotFoundError(id));
+        const originalEntry = getResult.value;
+        const canAccessEntry = await this.accessControl.canAccessEntry({
+            model,
+            entry: originalEntry,
+            rwd: "w"
+        });
+        if (!canAccessEntry) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const currentDateTime = new Date().toISOString();
+        const currentIdentity = this.identityContext.getIdentity();
+        const entryToRestore = {
+            ...originalEntry,
+            wbyDeleted: false,
+            location: {
+                folderId: originalEntry.binOriginalFolderId
+            },
+            binOriginalFolderId: void 0,
+            restoredOn: getDate(currentDateTime, null),
+            restoredBy: getIdentity(currentIdentity, null),
+            revisionRestoredOn: getDate(currentDateTime, null),
+            revisionRestoredBy: getIdentity(currentIdentity, null)
+        };
+        try {
+            await this.eventPublisher.publish(new EntryBeforeRestoreFromBinEvent({
+                entry: entryToRestore,
+                model
+            }));
+            const result = await this.repository.execute(model, entryToRestore);
+            if (result.isFail()) {
+                await this.eventPublisher.publish(new EntryRestoreFromBinErrorEvent({
+                    entry: entryToRestore,
+                    model,
+                    error: result.error
+                }));
+                return Result.fail(result.error);
+            }
+            const restoredEntry = result.value;
+            await this.eventPublisher.publish(new EntryAfterRestoreFromBinEvent({
+                entry: restoredEntry,
+                model
+            }));
+            return Result.ok(restoredEntry);
+        } catch (error) {
+            await this.eventPublisher.publish(new EntryRestoreFromBinErrorEvent({
+                entry: entryToRestore,
+                model,
+                error: error
+            }));
+            return Result.fail(error);
+        }
+    }
+}
+const RestoreEntryFromBinUseCase_RestoreEntryFromBinUseCase = createImplementation({
+    abstraction: RestoreEntryFromBinUseCase,
+    implementation: RestoreEntryFromBinUseCaseImpl,
+    dependencies: [
+        RestoreEntryFromBinRepository,
+        AccessControl,
+        GetLatestDeletedRevisionByEntryIdUseCase,
+        IdentityContext,
+        EventPublisher
+    ]
+});
+export { RestoreEntryFromBinUseCase_RestoreEntryFromBinUseCase as RestoreEntryFromBinUseCase };
+
+//# sourceMappingURL=RestoreEntryFromBinUseCase.js.map

package/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinUseCase.js","sources":["../../../../src/features/contentEntry/RestoreEntryFromBin/RestoreEntryFromBinUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { RestoreEntryFromBinUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { RestoreEntryFromBinRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { GetLatestDeletedRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport {\n    EntryBeforeRestoreFromBinEvent,\n    EntryAfterRestoreFromBinEvent,\n    EntryRestoreFromBinErrorEvent\n} from \"./events.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\nimport { getDate } from \"~/utils/date.js\";\nimport { getIdentity } from \"~/utils/identity.js\";\n\n/**\n * RestoreEntryFromBinUseCase - Orchestrates restoring a soft-deleted entry from the bin.\n *\n * Responsibilities:\n * - Apply access control\n * - Get the deleted entry to restore by ID\n * - Clear deletion flags (wbyDeleted = false)\n * - Restore entry to its original folder\n * - Update restoration metadata\n * - Publish domain events\n * - Delegate to repository for storage operations\n */\nclass RestoreEntryFromBinUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: RestoreEntryFromBinRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private getDeletedEntry: GetLatestDeletedRevisionByEntryIdUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private eventPublisher: EventPublisher.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\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 deleted entry to restore by ID\n        const getResult = await this.getDeletedEntry.execute<T>(model, { id });\n\n        if (getResult.isFail()) {\n            return Result.fail(new EntryNotFoundError(id));\n        }\n\n        const originalEntry = getResult.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        });\n\n        if (!canAccessEntry) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Create the restored entry data\n        const currentDateTime = new Date().toISOString();\n        const currentIdentity = this.identityContext.getIdentity();\n\n        const entryToRestore: CmsEntry<T> = {\n            ...originalEntry,\n            wbyDeleted: false,\n\n            // Entry location fields - restore to original folder\n            location: {\n                folderId: originalEntry.binOriginalFolderId\n            },\n            binOriginalFolderId: undefined,\n\n            // Entry-level meta fields\n            restoredOn: getDate(currentDateTime, null),\n            restoredBy: getIdentity(currentIdentity, null),\n\n            // Revision-level meta fields\n            revisionRestoredOn: getDate(currentDateTime, null),\n            revisionRestoredBy: getIdentity(currentIdentity, null)\n        };\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryBeforeRestoreFromBinEvent({\n                    entry: entryToRestore,\n                    model\n                })\n            );\n\n            // Delegate to repository\n            const result = await this.repository.execute<T>(model, entryToRestore);\n\n            if (result.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryRestoreFromBinErrorEvent({\n                        entry: entryToRestore,\n                        model,\n                        error: result.error\n                    })\n                );\n                return Result.fail(result.error);\n            }\n\n            const restoredEntry = result.value;\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterRestoreFromBinEvent({\n                    entry: restoredEntry,\n                    model\n                })\n            );\n\n            return Result.ok(restoredEntry);\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryRestoreFromBinErrorEvent({\n                    entry: entryToRestore,\n                    model,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const RestoreEntryFromBinUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: RestoreEntryFromBinUseCaseImpl,\n    dependencies: [\n        RestoreEntryFromBinRepository,\n        AccessControl,\n        GetLatestDeletedRevisionByEntryIdUseCase,\n        IdentityContext,\n        EventPublisher\n    ]\n});\n"],"names":["RestoreEntryFromBinUseCaseImpl","repository","accessControl","getDeletedEntry","identityContext","eventPublisher","model","id","canAccess","Result","EntryNotAuthorizedError","getResult","EntryNotFoundError","originalEntry","canAccessEntry","currentDateTime","Date","currentIdentity","entryToRestore","undefined","getDate","getIdentity","EntryBeforeRestoreFromBinEvent","result","EntryRestoreFromBinErrorEvent","restoredEntry","EntryAfterRestoreFromBinEvent","error","RestoreEntryFromBinUseCase","createImplementation","UseCaseAbstraction","RestoreEntryFromBinRepository","AccessControl","GetLatestDeletedRevisionByEntryIdUseCase","IdentityContext","EventPublisher"],"mappings":";;;;;;;;;;AA+BA,MAAMA;IACF,YACYC,UAAmD,EACnDC,aAAsC,EACtCC,eAAmE,EACnEC,eAA0C,EAC1CC,cAAwC,CAClD;aALUJ,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,eAAe,GAAfA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAa,QACTC,KAAe,EACfC,EAAU,EAC4C;QAEtD,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEF;YAAO,KAAK;QAAI;QAC5E,IAAI,CAACE,WACD,OAAOC,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAIzD,MAAMK,YAAY,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAIL,OAAO;YAAEC;QAAG;QAEpE,IAAII,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAAC,IAAIG,mBAAmBL;QAG9C,MAAMM,gBAAgBF,UAAU,KAAK;QAGrC,MAAMG,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAC3DR;YACA,OAAOO;YACP,KAAK;QACT;QAEA,IAAI,CAACC,gBACD,OAAOL,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAIzD,MAAMS,kBAAkB,IAAIC,OAAO,WAAW;QAC9C,MAAMC,kBAAkB,IAAI,CAAC,eAAe,CAAC,WAAW;QAExD,MAAMC,iBAA8B;YAChC,GAAGL,aAAa;YAChB,YAAY;YAGZ,UAAU;gBACN,UAAUA,cAAc,mBAAmB;YAC/C;YACA,qBAAqBM;YAGrB,YAAYC,QAAQL,iBAAiB;YACrC,YAAYM,YAAYJ,iBAAiB;YAGzC,oBAAoBG,QAAQL,iBAAiB;YAC7C,oBAAoBM,YAAYJ,iBAAiB;QACrD;QAEA,IAAI;YAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIK,+BAA+B;gBAC/B,OAAOJ;gBACPZ;YACJ;YAIJ,MAAMiB,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAIjB,OAAOY;YAEvD,IAAIK,OAAO,MAAM,IAAI;gBACjB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;oBAC9B,OAAON;oBACPZ;oBACA,OAAOiB,OAAO,KAAK;gBACvB;gBAEJ,OAAOd,OAAO,IAAI,CAACc,OAAO,KAAK;YACnC;YAEA,MAAME,gBAAgBF,OAAO,KAAK;YAGlC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,8BAA8B;gBAC9B,OAAOD;gBACPnB;YACJ;YAGJ,OAAOG,OAAO,EAAE,CAACgB;QACrB,EAAE,OAAOE,OAAO;YACZ,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIH,8BAA8B;gBAC9B,OAAON;gBACPZ;gBACA,OAAOqB;YACX;YAEJ,OAAOlB,OAAO,IAAI,CAACkB;QACvB;IACJ;AACJ;AAEO,MAAMC,wDAA6BC,qBAAqB;IAC3D,aAAaC;IACb,gBAAgB9B;IAChB,cAAc;QACV+B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}