@webiny/api-headless-cms 0.0.0-unstable.6f45466a1d → 0.0.0-unstable.7be00a75a9

package/features/contentEntry/UnpublishEntry/UnpublishEntryUseCase.js

@@ -1,126 +1,81 @@
-import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
-import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
-import { Result } from "@webiny/feature/api";
-import { createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { Result, createImplementation } from "@webiny/feature/api";
 import { parseIdentifier } from "@webiny/utils";
-import { UnpublishEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
-import { UnpublishEntryRepository } from "./abstractions.js";
-import { EntryBeforeUnpublishEvent } from "./events.js";
-import { EntryAfterUnpublishEvent } from "./events.js";
-import { EntryUnpublishErrorEvent } from "./events.js";
+import { UnpublishEntryRepository, UnpublishEntryUseCase } from "./abstractions.js";
+import { EntryAfterUnpublishEvent, EntryBeforeUnpublishEvent, EntryUnpublishErrorEvent } from "./events.js";
 import { AccessControl } from "../../shared/abstractions.js";
 import { GetPublishedRevisionByEntryIdUseCase } from "../GetPublishedRevisionByEntryId/index.js";
-import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
-import { EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
-import { EntryValidationError } from "../../../domain/contentEntry/errors.js";
-import { createUnpublishEntryData } from "../../../crud/contentEntry/entryDataFactories/index.js";
-
-/**
- * UnpublishEntryUseCase - Orchestrates entry unpublishing.
- *
- * Responsibilities:
- * - Fetch published revision by entry ID
- * - Validate entry is published (matches requested ID)
- * - Transform to unpublish data
- * - Apply access control
- * - Publish domain events
- * - Delegate persistence to repository
- */
+import { EntryNotAuthorizedError, EntryNotFoundError, EntryValidationError } from "../../../domain/contentEntry/errors.js";
+import { CreateUnpublishEntryDataFactory } from "../entryDataFactories/CreateUnpublishEntryDataFactory/index.js";
 class UnpublishEntryUseCaseImpl {
-  constructor(eventPublisher, repository, accessControl, identityContext, getPublishedRevisionByEntryId) {
-    this.eventPublisher = eventPublisher;
-    this.repository = repository;
-    this.accessControl = accessControl;
-    this.identityContext = identityContext;
-    this.getPublishedRevisionByEntryId = getPublishedRevisionByEntryId;
-  }
-  async execute(model, id) {
-    // Check initial access control
-    const canAccess = await this.accessControl.canAccessEntry({
-      model,
-      pw: "u"
-    });
-    if (!canAccess) {
-      return Result.fail(EntryNotAuthorizedError.fromModel(model));
-    }
-
-    // Parse entry ID from revision ID
-    const {
-      id: entryId
-    } = parseIdentifier(id);
-
-    // Get published revision
-    const publishedResult = await this.getPublishedRevisionByEntryId.execute(model, entryId);
-    if (publishedResult.isFail()) {
-      return Result.fail(publishedResult.error);
-    }
-    const originalEntry = publishedResult.value;
-    if (!originalEntry) {
-      return Result.fail(new EntryNotFoundError(id));
-    }
-
-    // Validate that the entry is actually published (published revision ID must match requested ID)
-    if (originalEntry.id !== id) {
-      return Result.fail(new EntryValidationError(`Entry is not published!`));
-    }
-
-    // Apply access control on the specific entry
-    const canAccessEntry = await this.accessControl.canAccessEntry({
-      model,
-      entry: originalEntry,
-      pw: "u"
-    });
-    if (!canAccessEntry) {
-      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    constructor(eventPublisher, repository, accessControl, getPublishedRevisionByEntryId, createUnpublishEntryDataFactory){
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+        this.accessControl = accessControl;
+        this.getPublishedRevisionByEntryId = getPublishedRevisionByEntryId;
+        this.createUnpublishEntryDataFactory = createUnpublishEntryDataFactory;
     }
-
-    // Transform to unpublish data
-    const {
-      entry
-    } = await createUnpublishEntryData({
-      originalEntry,
-      getIdentity: () => this.identityContext.getIdentity()
-    });
-    try {
-      // Publish before event
-      await this.eventPublisher.publish(new EntryBeforeUnpublishEvent({
-        entry,
-        model
-      }));
-
-      // Persist unpublish
-      const unpublishResult = await this.repository.execute(model, entry);
-      if (unpublishResult.isFail()) {
-        await this.eventPublisher.publish(new EntryUnpublishErrorEvent({
-          entry,
-          model,
-          error: unpublishResult.error
-        }));
-        return Result.fail(unpublishResult.error);
-      }
-      const storageEntry = unpublishResult.value;
-
-      // Publish after event
-      await this.eventPublisher.publish(new EntryAfterUnpublishEvent({
-        entry,
-        storageEntry,
-        model
-      }));
-      return Result.ok(entry);
-    } catch (error) {
-      await this.eventPublisher.publish(new EntryUnpublishErrorEvent({
-        entry,
-        model,
-        error: error
-      }));
-      return Result.fail(error);
+    async execute(model, id) {
+        const canAccess = await this.accessControl.canAccessEntry({
+            model,
+            pw: "u"
+        });
+        if (!canAccess) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const { id: entryId } = parseIdentifier(id);
+        const publishedResult = await this.getPublishedRevisionByEntryId.execute(model, entryId);
+        if (publishedResult.isFail()) return Result.fail(publishedResult.error);
+        const originalEntry = publishedResult.value;
+        if (!originalEntry) return Result.fail(new EntryNotFoundError(id));
+        if (originalEntry.id !== id) return Result.fail(new EntryValidationError("Entry is not published!"));
+        const canAccessEntry = await this.accessControl.canAccessEntry({
+            model,
+            entry: originalEntry,
+            pw: "u"
+        });
+        if (!canAccessEntry) return Result.fail(EntryNotAuthorizedError.fromModel(model));
+        const { entry } = await this.createUnpublishEntryDataFactory.create(originalEntry);
+        try {
+            await this.eventPublisher.publish(new EntryBeforeUnpublishEvent({
+                entry,
+                model
+            }));
+            const unpublishResult = await this.repository.execute(model, entry);
+            if (unpublishResult.isFail()) {
+                await this.eventPublisher.publish(new EntryUnpublishErrorEvent({
+                    entry,
+                    model,
+                    error: unpublishResult.error
+                }));
+                return Result.fail(unpublishResult.error);
+            }
+            const storageEntry = unpublishResult.value;
+            await this.eventPublisher.publish(new EntryAfterUnpublishEvent({
+                entry,
+                storageEntry,
+                model
+            }));
+            return Result.ok(entry);
+        } catch (error) {
+            await this.eventPublisher.publish(new EntryUnpublishErrorEvent({
+                entry,
+                model,
+                error: error
+            }));
+            return Result.fail(error);
+        }
     }
-  }
 }
-export const UnpublishEntryUseCase = createImplementation({
-  abstraction: UseCaseAbstraction,
-  implementation: UnpublishEntryUseCaseImpl,
-  dependencies: [EventPublisher, UnpublishEntryRepository, AccessControl, IdentityContext, GetPublishedRevisionByEntryIdUseCase]
+const UnpublishEntryUseCase_UnpublishEntryUseCase = createImplementation({
+    abstraction: UnpublishEntryUseCase,
+    implementation: UnpublishEntryUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        UnpublishEntryRepository,
+        AccessControl,
+        GetPublishedRevisionByEntryIdUseCase,
+        CreateUnpublishEntryDataFactory
+    ]
 });
+export { UnpublishEntryUseCase_UnpublishEntryUseCase as UnpublishEntryUseCase };
 
 //# sourceMappingURL=UnpublishEntryUseCase.js.map

package/features/contentEntry/UnpublishEntry/UnpublishEntryUseCase.js.map

@@ -1 +1 @@
-{"version":3,"names":["EventPublisher","IdentityContext","Result","createImplementation","parseIdentifier","UnpublishEntryUseCase","UseCaseAbstraction","UnpublishEntryRepository","EntryBeforeUnpublishEvent","EntryAfterUnpublishEvent","EntryUnpublishErrorEvent","AccessControl","GetPublishedRevisionByEntryIdUseCase","EntryNotAuthorizedError","EntryNotFoundError","EntryValidationError","createUnpublishEntryData","UnpublishEntryUseCaseImpl","constructor","eventPublisher","repository","accessControl","identityContext","getPublishedRevisionByEntryId","execute","model","id","canAccess","canAccessEntry","pw","fail","fromModel","entryId","publishedResult","isFail","error","originalEntry","value","entry","getIdentity","publish","unpublishResult","storageEntry","ok","abstraction","implementation","dependencies"],"sources":["UnpublishEntryUseCase.ts"],"sourcesContent":["import { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { UnpublishEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UnpublishEntryRepository } from \"./abstractions.js\";\nimport { EntryBeforeUnpublishEvent } from \"./events.js\";\nimport { EntryAfterUnpublishEvent } from \"./events.js\";\nimport { EntryUnpublishErrorEvent } from \"./events.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { GetPublishedRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetPublishedRevisionByEntryId/index.js\";\nimport type { CmsEntry, CmsEntryValues } from \"~/types/index.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport { createUnpublishEntryData } from \"~/crud/contentEntry/entryDataFactories/index.js\";\n\n/**\n * UnpublishEntryUseCase - Orchestrates entry unpublishing.\n *\n * Responsibilities:\n * - Fetch published revision by entry ID\n * - Validate entry is published (matches requested ID)\n * - Transform to unpublish data\n * - Apply access control\n * - Publish domain events\n * - Delegate persistence to repository\n */\nclass UnpublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UnpublishEntryRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private identityContext: IdentityContext.Interface,\n        private getPublishedRevisionByEntryId: GetPublishedRevisionByEntryIdUseCase.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 initial access control\n        const canAccess = await this.accessControl.canAccessEntry({ model, pw: \"u\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Parse entry ID from revision ID\n        const { id: entryId } = parseIdentifier(id);\n\n        // Get published revision\n        const publishedResult = await this.getPublishedRevisionByEntryId.execute<T>(model, entryId);\n\n        if (publishedResult.isFail()) {\n            return Result.fail(publishedResult.error);\n        }\n\n        const originalEntry = publishedResult.value;\n\n        if (!originalEntry) {\n            return Result.fail(new EntryNotFoundError(id));\n        }\n\n        // Validate that the entry is actually published (published revision ID must match requested ID)\n        if (originalEntry.id !== id) {\n            return Result.fail(new EntryValidationError(`Entry is not published!`));\n        }\n\n        // Apply access control on the specific entry\n        const canAccessEntry = await this.accessControl.canAccessEntry({\n            model,\n            entry: originalEntry,\n            pw: \"u\"\n        });\n\n        if (!canAccessEntry) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Transform to unpublish data\n        const { entry } = await createUnpublishEntryData<T>({\n            originalEntry,\n            getIdentity: () => this.identityContext.getIdentity()\n        });\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(new EntryBeforeUnpublishEvent({ entry, model }));\n\n            // Persist unpublish\n            const unpublishResult = await this.repository.execute<T>(model, entry);\n            if (unpublishResult.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryUnpublishErrorEvent({ entry, model, error: unpublishResult.error })\n                );\n                return Result.fail(unpublishResult.error);\n            }\n\n            const storageEntry = unpublishResult.value;\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterUnpublishEvent({\n                    entry,\n                    storageEntry,\n                    model\n                })\n            );\n\n            return Result.ok(entry);\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryUnpublishErrorEvent({ entry, model, error: error as Error })\n            );\n            return Result.fail(error as UseCaseAbstraction.Error);\n        }\n    }\n}\n\nexport const UnpublishEntryUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: UnpublishEntryUseCaseImpl,\n    dependencies: [\n        EventPublisher,\n        UnpublishEntryRepository,\n        AccessControl,\n        IdentityContext,\n        GetPublishedRevisionByEntryIdUseCase\n    ]\n});\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"features/contentEntry/UnpublishEntry/UnpublishEntryUseCase.js","sources":["../../../../src/features/contentEntry/UnpublishEntry/UnpublishEntryUseCase.ts"],"sourcesContent":["import { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { UnpublishEntryUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UnpublishEntryRepository } from \"./abstractions.js\";\nimport { EntryBeforeUnpublishEvent } from \"./events.js\";\nimport { EntryAfterUnpublishEvent } from \"./events.js\";\nimport { EntryUnpublishErrorEvent } from \"./events.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { GetPublishedRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetPublishedRevisionByEntryId/index.js\";\nimport type { CmsEntry, CmsEntryValues } from \"~/types/index.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport { CreateUnpublishEntryDataFactory } from \"~/features/contentEntry/entryDataFactories/CreateUnpublishEntryDataFactory/index.js\";\n\nclass UnpublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UnpublishEntryRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private getPublishedRevisionByEntryId: GetPublishedRevisionByEntryIdUseCase.Interface,\n        private createUnpublishEntryDataFactory: CreateUnpublishEntryDataFactory.Interface\n    ) {}\n\n    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, pw: \"u\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        const { id: entryId } = parseIdentifier(id);\n\n        const publishedResult = await this.getPublishedRevisionByEntryId.execute<T>(model, entryId);\n\n        if (publishedResult.isFail()) {\n            return Result.fail(publishedResult.error);\n        }\n\n        const originalEntry = publishedResult.value;\n\n        if (!originalEntry) {\n            return Result.fail(new EntryNotFoundError(id));\n        }\n\n        if (originalEntry.id !== id) {\n            return Result.fail(new EntryValidationError(`Entry is not published!`));\n        }\n\n        const canAccessEntry = await this.accessControl.canAccessEntry({\n            model,\n            entry: originalEntry,\n            pw: \"u\"\n        });\n\n        if (!canAccessEntry) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        const { entry } = await this.createUnpublishEntryDataFactory.create<T>(originalEntry);\n\n        try {\n            await this.eventPublisher.publish(new EntryBeforeUnpublishEvent({ entry, model }));\n\n            const unpublishResult = await this.repository.execute<T>(model, entry);\n            if (unpublishResult.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryUnpublishErrorEvent({ entry, model, error: unpublishResult.error })\n                );\n                return Result.fail(unpublishResult.error);\n            }\n\n            const storageEntry = unpublishResult.value;\n\n            await this.eventPublisher.publish(\n                new EntryAfterUnpublishEvent({\n                    entry,\n                    storageEntry,\n                    model\n                })\n            );\n\n            return Result.ok(entry);\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryUnpublishErrorEvent({ entry, model, error: error as Error })\n            );\n            return Result.fail(error as UseCaseAbstraction.Error);\n        }\n    }\n}\n\nexport const UnpublishEntryUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: UnpublishEntryUseCaseImpl,\n    dependencies: [\n        EventPublisher,\n        UnpublishEntryRepository,\n        AccessControl,\n        GetPublishedRevisionByEntryIdUseCase,\n        CreateUnpublishEntryDataFactory\n    ]\n});\n"],"names":["UnpublishEntryUseCaseImpl","eventPublisher","repository","accessControl","getPublishedRevisionByEntryId","createUnpublishEntryDataFactory","model","id","canAccess","Result","EntryNotAuthorizedError","entryId","parseIdentifier","publishedResult","originalEntry","EntryNotFoundError","EntryValidationError","canAccessEntry","entry","EntryBeforeUnpublishEvent","unpublishResult","EntryUnpublishErrorEvent","storageEntry","EntryAfterUnpublishEvent","error","UnpublishEntryUseCase","createImplementation","UseCaseAbstraction","EventPublisher","UnpublishEntryRepository","AccessControl","GetPublishedRevisionByEntryIdUseCase","CreateUnpublishEntryDataFactory"],"mappings":";;;;;;;;;AAkBA,MAAMA;IACF,YACYC,cAAwC,EACxCC,UAA8C,EAC9CC,aAAsC,EACtCC,6BAA6E,EAC7EC,+BAA0E,CACpF;aALUJ,cAAc,GAAdA;aACAC,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,6BAA6B,GAA7BA;aACAC,+BAA+B,GAA/BA;IACT;IAEH,MAAM,QACFC,KAAe,EACfC,EAAU,EAC4C;QACtD,MAAMC,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAEF;YAAO,IAAI;QAAI;QAC3E,IAAI,CAACE,WACD,OAAOC,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAGzD,MAAM,EAAE,IAAIK,OAAO,EAAE,GAAGC,gBAAgBL;QAExC,MAAMM,kBAAkB,MAAM,IAAI,CAAC,6BAA6B,CAAC,OAAO,CAAIP,OAAOK;QAEnF,IAAIE,gBAAgB,MAAM,IACtB,OAAOJ,OAAO,IAAI,CAACI,gBAAgB,KAAK;QAG5C,MAAMC,gBAAgBD,gBAAgB,KAAK;QAE3C,IAAI,CAACC,eACD,OAAOL,OAAO,IAAI,CAAC,IAAIM,mBAAmBR;QAG9C,IAAIO,cAAc,EAAE,KAAKP,IACrB,OAAOE,OAAO,IAAI,CAAC,IAAIO,qBAAqB;QAGhD,MAAMC,iBAAiB,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAC3DX;YACA,OAAOQ;YACP,IAAI;QACR;QAEA,IAAI,CAACG,gBACD,OAAOR,OAAO,IAAI,CAACC,wBAAwB,SAAS,CAACJ;QAGzD,MAAM,EAAEY,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,MAAM,CAAIJ;QAEvE,IAAI;YACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIK,0BAA0B;gBAAED;gBAAOZ;YAAM;YAE/E,MAAMc,kBAAkB,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAId,OAAOY;YAChE,IAAIE,gBAAgB,MAAM,IAAI;gBAC1B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,yBAAyB;oBAAEH;oBAAOZ;oBAAO,OAAOc,gBAAgB,KAAK;gBAAC;gBAE9E,OAAOX,OAAO,IAAI,CAACW,gBAAgB,KAAK;YAC5C;YAEA,MAAME,eAAeF,gBAAgB,KAAK;YAE1C,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,yBAAyB;gBACzBL;gBACAI;gBACAhB;YACJ;YAGJ,OAAOG,OAAO,EAAE,CAACS;QACrB,EAAE,OAAOM,OAAO;YACZ,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIH,yBAAyB;gBAAEH;gBAAOZ;gBAAO,OAAOkB;YAAe;YAEvE,OAAOf,OAAO,IAAI,CAACe;QACvB;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,qBAAqB;IACtD,aAAaC;IACb,gBAAgB3B;IAChB,cAAc;QACV4B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -14,6 +14,7 @@ export interface IUnpublishEntryUseCaseErrors {
     repository: RepositoryError;
 }
 type UseCaseError = IUnpublishEntryUseCaseErrors[keyof IUnpublishEntryUseCaseErrors];
+/** Unpublish a content entry. */
 export declare const UnpublishEntryUseCase: import("@webiny/di").Abstraction<IUnpublishEntryUseCase>;
 export declare namespace UnpublishEntryUseCase {
     type Interface = IUnpublishEntryUseCase;

package/features/contentEntry/UnpublishEntry/abstractions.js

@@ -1,16 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-/**
- * UnpublishEntry Use Case
- */
-
-export const UnpublishEntryUseCase = createAbstraction("UnpublishEntryUseCase");
-
-/**
- * UnpublishEntryRepository - Persists entry unpublish to storage.
- * Takes a domain CmsEntry object and unpublishes it.
- */
-
-export const UnpublishEntryRepository = createAbstraction("UnpublishEntryRepository");
+const UnpublishEntryUseCase = createAbstraction("UnpublishEntryUseCase");
+const UnpublishEntryRepository = createAbstraction("UnpublishEntryRepository");
+export { UnpublishEntryRepository, UnpublishEntryUseCase };
 
 //# sourceMappingURL=abstractions.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","UnpublishEntryUseCase","UnpublishEntryRepository"],"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 * UnpublishEntry Use Case\n */\nexport interface IUnpublishEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IUnpublishEntryUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    validation: EntryValidationError;\n    repository: RepositoryError;\n}\n\ntype UseCaseError = IUnpublishEntryUseCaseErrors[keyof IUnpublishEntryUseCaseErrors];\n\nexport const UnpublishEntryUseCase =\n    createAbstraction<IUnpublishEntryUseCase>(\"UnpublishEntryUseCase\");\n\nexport namespace UnpublishEntryUseCase {\n    export type Interface = IUnpublishEntryUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<\n        Result<CmsEntry<T>, UseCaseError>\n    >;\n}\n\n/**\n * UnpublishEntryRepository - Persists entry unpublish to storage.\n * Takes a domain CmsEntry object and unpublishes it.\n */\nexport interface IUnpublishEntryRepository {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<CmsEntry<T>, RepositoryError>>;\n}\n\nexport interface IUnpublishEntryRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError = IUnpublishEntryRepositoryErrors[keyof IUnpublishEntryRepositoryErrors];\n\nexport const UnpublishEntryRepository = createAbstraction<IUnpublishEntryRepository>(\n    \"UnpublishEntryRepository\"\n);\n\nexport namespace UnpublishEntryRepository {\n    export type Interface = IUnpublishEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAS/D;AACA;AACA;;AAiBA,OAAO,MAAMC,qBAAqB,GAC9BD,iBAAiB,CAAyB,uBAAuB,CAAC;;AAUtE;AACA;AACA;AACA;;AAcA,OAAO,MAAME,wBAAwB,GAAGF,iBAAiB,CACrD,0BACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentEntry/UnpublishEntry/abstractions.js","sources":["../../../../src/features/contentEntry/UnpublishEntry/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 * UnpublishEntry Use Case\n */\nexport interface IUnpublishEntryUseCase {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        id: string\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IUnpublishEntryUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    validation: EntryValidationError;\n    repository: RepositoryError;\n}\n\ntype UseCaseError = IUnpublishEntryUseCaseErrors[keyof IUnpublishEntryUseCaseErrors];\n\n/** Unpublish a content entry. */\nexport const UnpublishEntryUseCase =\n    createAbstraction<IUnpublishEntryUseCase>(\"UnpublishEntryUseCase\");\n\nexport namespace UnpublishEntryUseCase {\n    export type Interface = IUnpublishEntryUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues = CmsEntryValues> = Promise<\n        Result<CmsEntry<T>, UseCaseError>\n    >;\n}\n\n/**\n * UnpublishEntryRepository - Persists entry unpublish to storage.\n * Takes a domain CmsEntry object and unpublishes it.\n */\nexport interface IUnpublishEntryRepository {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<CmsEntry<T>, RepositoryError>>;\n}\n\nexport interface IUnpublishEntryRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError = IUnpublishEntryRepositoryErrors[keyof IUnpublishEntryRepositoryErrors];\n\nexport const UnpublishEntryRepository = createAbstraction<IUnpublishEntryRepository>(\n    \"UnpublishEntryRepository\"\n);\n\nexport namespace UnpublishEntryRepository {\n    export type Interface = IUnpublishEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UnpublishEntryUseCase","createAbstraction","UnpublishEntryRepository"],"mappings":";AA6BO,MAAMA,wBACTC,kBAA0C;AA2BvC,MAAMC,2BAA2BD,kBACpC"}

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

@@ -1,5 +1,5 @@
-import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
-import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
 import type { CmsEntry } from "../../../types/index.js";
 import type { CmsModel } from "../../../types/index.js";
 /**
@@ -26,6 +26,7 @@ export declare class EntryBeforeUnpublishEvent extends DomainEvent<EntryBeforeUn
     eventType: "Cms/Entry/BeforeUnpublish";
     getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnpublishEvent>>;
 }
+/** Hook into entry lifecycle before an entry is unpublished. */
 export declare const EntryBeforeUnpublishEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnpublishEvent>>;
 export declare namespace EntryBeforeUnpublishEventHandler {
     type Interface = IEventHandler<EntryBeforeUnpublishEvent>;
@@ -38,6 +39,7 @@ export declare class EntryAfterUnpublishEvent extends DomainEvent<EntryAfterUnpu
     eventType: "Cms/Entry/AfterUnpublish";
     getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnpublishEvent>>;
 }
+/** Hook into entry lifecycle after an entry is unpublished. */
 export declare const EntryAfterUnpublishEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnpublishEvent>>;
 export declare namespace EntryAfterUnpublishEventHandler {
     type Interface = IEventHandler<EntryAfterUnpublishEvent>;

package/features/contentEntry/UnpublishEntry/events.js

@@ -1,39 +1,32 @@
 import { createAbstraction } from "@webiny/feature/api";
-import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
-
-/**
- * Event payloads
- */
-
-/**
- * EntryBeforeUnpublishEvent - Published before unpublishing an entry
- */
-export class EntryBeforeUnpublishEvent extends DomainEvent {
-  eventType = "Cms/Entry/BeforeUnpublish";
-  getHandlerAbstraction() {
-    return EntryBeforeUnpublishEventHandler;
-  }
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class EntryBeforeUnpublishEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeUnpublishEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/BeforeUnpublish";
+    }
 }
-export const EntryBeforeUnpublishEventHandler = createAbstraction("EntryBeforeUnpublishEventHandler");
-/**
- * EntryAfterUnpublishEvent - Published after unpublishing an entry
- */
-export class EntryAfterUnpublishEvent extends DomainEvent {
-  eventType = "Cms/Entry/AfterUnpublish";
-  getHandlerAbstraction() {
-    return EntryAfterUnpublishEventHandler;
-  }
+const EntryBeforeUnpublishEventHandler = createAbstraction("EntryBeforeUnpublishEventHandler");
+class EntryAfterUnpublishEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterUnpublishEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/AfterUnpublish";
+    }
 }
-export const EntryAfterUnpublishEventHandler = createAbstraction("EntryAfterUnpublishEventHandler");
-/**
- * EntryUnpublishErrorEvent - Published when unpublish fails
- */
-export class EntryUnpublishErrorEvent extends DomainEvent {
-  eventType = "Cms/Entry/UnpublishError";
-  getHandlerAbstraction() {
-    return EntryUnpublishErrorEventHandler;
-  }
+const EntryAfterUnpublishEventHandler = createAbstraction("EntryAfterUnpublishEventHandler");
+class EntryUnpublishErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryUnpublishErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/UnpublishError";
+    }
 }
-export const EntryUnpublishErrorEventHandler = createAbstraction("EntryUnpublishErrorEventHandler");
+const EntryUnpublishErrorEventHandler = createAbstraction("EntryUnpublishErrorEventHandler");
+export { EntryAfterUnpublishEvent, EntryAfterUnpublishEventHandler, EntryBeforeUnpublishEvent, EntryBeforeUnpublishEventHandler, EntryUnpublishErrorEvent, EntryUnpublishErrorEventHandler };
 
 //# sourceMappingURL=events.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforeUnpublishEvent","eventType","getHandlerAbstraction","EntryBeforeUnpublishEventHandler","EntryAfterUnpublishEvent","EntryAfterUnpublishEventHandler","EntryUnpublishErrorEvent","EntryUnpublishErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport type { CmsEntry } from \"~/types/index.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface EntryBeforeUnpublishEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n}\n\nexport interface EntryAfterUnpublishEventPayload {\n    entry: CmsEntry;\n    storageEntry: any;\n    model: CmsModel;\n}\n\nexport interface EntryUnpublishErrorEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * EntryBeforeUnpublishEvent - Published before unpublishing an entry\n */\nexport class EntryBeforeUnpublishEvent extends DomainEvent<EntryBeforeUnpublishEventPayload> {\n    eventType = \"Cms/Entry/BeforeUnpublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeUnpublishEventHandler;\n    }\n}\n\nexport const EntryBeforeUnpublishEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeUnpublishEvent>\n>(\"EntryBeforeUnpublishEventHandler\");\n\nexport namespace EntryBeforeUnpublishEventHandler {\n    export type Interface = IEventHandler<EntryBeforeUnpublishEvent>;\n    export type Event = EntryBeforeUnpublishEvent;\n}\n\n/**\n * EntryAfterUnpublishEvent - Published after unpublishing an entry\n */\nexport class EntryAfterUnpublishEvent extends DomainEvent<EntryAfterUnpublishEventPayload> {\n    eventType = \"Cms/Entry/AfterUnpublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUnpublishEventHandler;\n    }\n}\n\nexport const EntryAfterUnpublishEventHandler = createAbstraction<\n    IEventHandler<EntryAfterUnpublishEvent>\n>(\"EntryAfterUnpublishEventHandler\");\n\nexport namespace EntryAfterUnpublishEventHandler {\n    export type Interface = IEventHandler<EntryAfterUnpublishEvent>;\n    export type Event = EntryAfterUnpublishEvent;\n}\n\n/**\n * EntryUnpublishErrorEvent - Published when unpublish fails\n */\nexport class EntryUnpublishErrorEvent extends DomainEvent<EntryUnpublishErrorEventPayload> {\n    eventType = \"Cms/Entry/UnpublishError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryUnpublishErrorEventHandler;\n    }\n}\n\nexport const EntryUnpublishErrorEventHandler = createAbstraction<\n    IEventHandler<EntryUnpublishErrorEvent>\n>(\"EntryUnpublishErrorEventHandler\");\n\nexport namespace EntryUnpublishErrorEventHandler {\n    export type Interface = IEventHandler<EntryUnpublishErrorEvent>;\n    export type Event = EntryUnpublishErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,0CAA0C;;AAKtE;AACA;AACA;;AAkBA;AACA;AACA;AACA,OAAO,MAAMC,yBAAyB,SAASD,WAAW,CAAmC;EACzFE,SAAS,GAAG,2BAA2B;EAEvCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,gCAAgC;EAC3C;AACJ;AAEA,OAAO,MAAMA,gCAAgC,GAAGL,iBAAiB,CAE/D,kCAAkC,CAAC;AAOrC;AACA;AACA;AACA,OAAO,MAAMM,wBAAwB,SAASL,WAAW,CAAkC;EACvFE,SAAS,GAAG,0BAA0B;EAEtCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,+BAA+B;EAC1C;AACJ;AAEA,OAAO,MAAMA,+BAA+B,GAAGP,iBAAiB,CAE9D,iCAAiC,CAAC;AAOpC;AACA;AACA;AACA,OAAO,MAAMQ,wBAAwB,SAASP,WAAW,CAAkC;EACvFE,SAAS,GAAG,0BAA0B;EAEtCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,+BAA+B;EAC1C;AACJ;AAEA,OAAO,MAAMA,+BAA+B,GAAGT,iBAAiB,CAE9D,iCAAiC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentEntry/UnpublishEntry/events.js","sources":["../../../../src/features/contentEntry/UnpublishEntry/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { CmsEntry } from \"~/types/index.js\";\nimport type { CmsModel } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface EntryBeforeUnpublishEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n}\n\nexport interface EntryAfterUnpublishEventPayload {\n    entry: CmsEntry;\n    storageEntry: any;\n    model: CmsModel;\n}\n\nexport interface EntryUnpublishErrorEventPayload {\n    entry: CmsEntry;\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * EntryBeforeUnpublishEvent - Published before unpublishing an entry\n */\nexport class EntryBeforeUnpublishEvent extends DomainEvent<EntryBeforeUnpublishEventPayload> {\n    eventType = \"Cms/Entry/BeforeUnpublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeUnpublishEventHandler;\n    }\n}\n\n/** Hook into entry lifecycle before an entry is unpublished. */\nexport const EntryBeforeUnpublishEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeUnpublishEvent>\n>(\"EntryBeforeUnpublishEventHandler\");\n\nexport namespace EntryBeforeUnpublishEventHandler {\n    export type Interface = IEventHandler<EntryBeforeUnpublishEvent>;\n    export type Event = EntryBeforeUnpublishEvent;\n}\n\n/**\n * EntryAfterUnpublishEvent - Published after unpublishing an entry\n */\nexport class EntryAfterUnpublishEvent extends DomainEvent<EntryAfterUnpublishEventPayload> {\n    eventType = \"Cms/Entry/AfterUnpublish\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUnpublishEventHandler;\n    }\n}\n\n/** Hook into entry lifecycle after an entry is unpublished. */\nexport const EntryAfterUnpublishEventHandler = createAbstraction<\n    IEventHandler<EntryAfterUnpublishEvent>\n>(\"EntryAfterUnpublishEventHandler\");\n\nexport namespace EntryAfterUnpublishEventHandler {\n    export type Interface = IEventHandler<EntryAfterUnpublishEvent>;\n    export type Event = EntryAfterUnpublishEvent;\n}\n\n/**\n * EntryUnpublishErrorEvent - Published when unpublish fails\n */\nexport class EntryUnpublishErrorEvent extends DomainEvent<EntryUnpublishErrorEventPayload> {\n    eventType = \"Cms/Entry/UnpublishError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryUnpublishErrorEventHandler;\n    }\n}\n\nexport const EntryUnpublishErrorEventHandler = createAbstraction<\n    IEventHandler<EntryUnpublishErrorEvent>\n>(\"EntryUnpublishErrorEventHandler\");\n\nexport namespace EntryUnpublishErrorEventHandler {\n    export type Interface = IEventHandler<EntryUnpublishErrorEvent>;\n    export type Event = EntryUnpublishErrorEvent;\n}\n"],"names":["EntryBeforeUnpublishEvent","DomainEvent","EntryBeforeUnpublishEventHandler","createAbstraction","EntryAfterUnpublishEvent","EntryAfterUnpublishEventHandler","EntryUnpublishErrorEvent","EntryUnpublishErrorEventHandler"],"mappings":";;AA6BO,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/UnpublishEntry/feature.d.ts

@@ -6,4 +6,7 @@
  * - Repository for persistence
  * - Events for extensibility
  */
-export declare const UnpublishEntryFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;
+export declare const UnpublishEntryFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentEntry/UnpublishEntry/feature.js

@@ -1,24 +1,13 @@
 import { createFeature } from "@webiny/feature/api";
 import { UnpublishEntryUseCase } from "./UnpublishEntryUseCase.js";
 import { UnpublishEntryRepository } from "./UnpublishEntryRepository.js";
-
-/**
- * UnpublishEntry Feature
- *
- * Provides complete functionality for unpublishing content entries:
- * - Use case for orchestration
- * - Repository for persistence
- * - Events for extensibility
- */
-export const UnpublishEntryFeature = createFeature({
-  name: "UnpublishEntry",
-  register(container) {
-    // Register use case in transient scope (new instance per request)
-    container.register(UnpublishEntryUseCase);
-
-    // Register repository in singleton scope (shared instance)
-    container.register(UnpublishEntryRepository).inSingletonScope();
-  }
+const UnpublishEntryFeature = createFeature({
+    name: "UnpublishEntry",
+    register (container) {
+        container.register(UnpublishEntryUseCase);
+        container.register(UnpublishEntryRepository).inSingletonScope();
+    }
 });
+export { UnpublishEntryFeature };
 
 //# sourceMappingURL=feature.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["createFeature","UnpublishEntryUseCase","UnpublishEntryRepository","UnpublishEntryFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UnpublishEntryUseCase } from \"./UnpublishEntryUseCase.js\";\nimport { UnpublishEntryRepository } from \"./UnpublishEntryRepository.js\";\n\n/**\n * UnpublishEntry Feature\n *\n * Provides complete functionality for unpublishing content entries:\n * - Use case for orchestration\n * - Repository for persistence\n * - Events for extensibility\n */\nexport const UnpublishEntryFeature = createFeature({\n    name: \"UnpublishEntry\",\n    register(container) {\n        // Register use case in transient scope (new instance per request)\n        container.register(UnpublishEntryUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(UnpublishEntryRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,qBAAqB;AAC9B,SAASC,wBAAwB;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,qBAAqB,GAAGH,aAAa,CAAC;EAC/CI,IAAI,EAAE,gBAAgB;EACtBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,qBAAqB,CAAC;;IAEzC;IACAK,SAAS,CAACD,QAAQ,CAACH,wBAAwB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACnE;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentEntry/UnpublishEntry/feature.js","sources":["../../../../src/features/contentEntry/UnpublishEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UnpublishEntryUseCase } from \"./UnpublishEntryUseCase.js\";\nimport { UnpublishEntryRepository } from \"./UnpublishEntryRepository.js\";\n\n/**\n * UnpublishEntry Feature\n *\n * Provides complete functionality for unpublishing content entries:\n * - Use case for orchestration\n * - Repository for persistence\n * - Events for extensibility\n */\nexport const UnpublishEntryFeature = createFeature({\n    name: \"UnpublishEntry\",\n    register(container) {\n        // Register use case in transient scope (new instance per request)\n        container.register(UnpublishEntryUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(UnpublishEntryRepository).inSingletonScope();\n    }\n});\n"],"names":["UnpublishEntryFeature","createFeature","container","UnpublishEntryUseCase","UnpublishEntryRepository"],"mappings":";;;AAYO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,0BAA0B,gBAAgB;IACjE;AACJ"}

package/features/contentEntry/UnpublishEntry/index.js

@@ -1,4 +1,2 @@
-export { UnpublishEntryUseCase, UnpublishEntryRepository } from "./abstractions.js";
+export { UnpublishEntryRepository, UnpublishEntryUseCase } from "./abstractions.js";
 export { EntryAfterUnpublishEventHandler, EntryBeforeUnpublishEventHandler } from "./events.js";
-
-//# sourceMappingURL=index.js.map

package/features/contentEntry/UpdateEntry/UpdateEntryRepository.js

@@ -1,39 +1,34 @@
-import { Result } from "@webiny/feature/api";
-import { createImplementation } from "@webiny/feature/api";
-import { UpdateEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { Result, createImplementation } from "@webiny/feature/api";
+import { UpdateEntryRepository } from "./abstractions.js";
 import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
 import { StorageOperations } from "../../shared/abstractions.js";
 import { EntryToStorageTransform } from "../../../legacy/abstractions.js";
-
-/**
- * UpdateEntryRepository - Handles persistence of entry updates.
- * Transforms domain entry to storage format and persists changes.
- */
 class UpdateEntryRepositoryImpl {
-  constructor(entryToStorageTransform, storageOperations) {
-    this.entryToStorageTransform = entryToStorageTransform;
-    this.storageOperations = storageOperations;
-  }
-  async execute(model, entry) {
-    try {
-      // Transform domain entry to storage format
-      const storageEntry = await this.entryToStorageTransform(model, entry);
-
-      // Persist to storage
-      await this.storageOperations.entries.update(model, {
-        entry,
-        storageEntry
-      });
-      return Result.ok();
-    } catch (error) {
-      return Result.fail(new EntryPersistenceError(error));
+    constructor(entryToStorageTransform, storageOperations){
+        this.entryToStorageTransform = entryToStorageTransform;
+        this.storageOperations = storageOperations;
+    }
+    async execute(model, entry) {
+        try {
+            const storageEntry = await this.entryToStorageTransform(model, entry);
+            await this.storageOperations.entries.update(model, {
+                entry,
+                storageEntry
+            });
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(new EntryPersistenceError(error));
+        }
     }
-  }
 }
-export const UpdateEntryRepository = createImplementation({
-  abstraction: RepositoryAbstraction,
-  implementation: UpdateEntryRepositoryImpl,
-  dependencies: [EntryToStorageTransform, StorageOperations]
+const UpdateEntryRepository_UpdateEntryRepository = createImplementation({
+    abstraction: UpdateEntryRepository,
+    implementation: UpdateEntryRepositoryImpl,
+    dependencies: [
+        EntryToStorageTransform,
+        StorageOperations
+    ]
 });
+export { UpdateEntryRepository_UpdateEntryRepository as UpdateEntryRepository };
 
 //# sourceMappingURL=UpdateEntryRepository.js.map

package/features/contentEntry/UpdateEntry/UpdateEntryRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","createImplementation","UpdateEntryRepository","RepositoryAbstraction","EntryPersistenceError","StorageOperations","EntryToStorageTransform","UpdateEntryRepositoryImpl","constructor","entryToStorageTransform","storageOperations","execute","model","entry","storageEntry","entries","update","ok","error","fail","abstraction","implementation","dependencies"],"sources":["UpdateEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { EntryToStorageTransform } from \"~/legacy/abstractions.js\";\n\n/**\n * UpdateEntryRepository - Handles persistence of entry updates.\n * Transforms domain entry to storage format and persists changes.\n */\nclass UpdateEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private entryToStorageTransform: EntryToStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            // Transform domain entry to storage format\n            const storageEntry = await this.entryToStorageTransform<T>(model, entry);\n\n            // Persist to storage\n            await this.storageOperations.entries.update<T>(model, {\n                entry,\n                storageEntry\n            });\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateEntryRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: UpdateEntryRepositoryImpl,\n    dependencies: [EntryToStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,qBAAqB,IAAIC,qBAAqB;AACvD,SAASC,qBAAqB;AAE9B,SAASC,iBAAiB;AAC1B,SAASC,uBAAuB;;AAEhC;AACA;AACA;AACA;AACA,MAAMC,yBAAyB,CAA4C;EAChEC,WAAWA,CACNC,uBAA0D,EAC1DC,iBAA8C,EACxD;IAAA,KAFUD,uBAA0D,GAA1DA,uBAA0D;IAAA,KAC1DC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAMC,OAAOA,CACTC,KAAe,EACfC,KAAkB,EACgC;IAClD,IAAI;MACA;MACA,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACL,uBAAuB,CAAIG,KAAK,EAAEC,KAAK,CAAC;;MAExE;MACA,MAAM,IAAI,CAACH,iBAAiB,CAACK,OAAO,CAACC,MAAM,CAAIJ,KAAK,EAAE;QAClDC,KAAK;QACLC;MACJ,CAAC,CAAC;MAEF,OAAOd,MAAM,CAACiB,EAAE,CAAC,CAAC;IACtB,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAIf,qBAAqB,CAACc,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMhB,qBAAqB,GAAGD,oBAAoB,CAAC;EACtDmB,WAAW,EAAEjB,qBAAqB;EAClCkB,cAAc,EAAEd,yBAAyB;EACzCe,YAAY,EAAE,CAAChB,uBAAuB,EAAED,iBAAiB;AAC7D,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/contentEntry/UpdateEntry/UpdateEntryRepository.js","sources":["../../../../src/features/contentEntry/UpdateEntry/UpdateEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { EntryToStorageTransform } from \"~/legacy/abstractions.js\";\n\n/**\n * UpdateEntryRepository - Handles persistence of entry updates.\n * Transforms domain entry to storage format and persists changes.\n */\nclass UpdateEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private entryToStorageTransform: EntryToStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entry: CmsEntry<T>\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            // Transform domain entry to storage format\n            const storageEntry = await this.entryToStorageTransform<T>(model, entry);\n\n            // Persist to storage\n            await this.storageOperations.entries.update<T>(model, {\n                entry,\n                storageEntry\n            });\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateEntryRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: UpdateEntryRepositoryImpl,\n    dependencies: [EntryToStorageTransform, StorageOperations]\n});\n"],"names":["UpdateEntryRepositoryImpl","entryToStorageTransform","storageOperations","model","entry","storageEntry","Result","error","EntryPersistenceError","UpdateEntryRepository","createImplementation","RepositoryAbstraction","EntryToStorageTransform","StorageOperations"],"mappings":";;;;;AAYA,MAAMA;IACF,YACYC,uBAA0D,EAC1DC,iBAA8C,CACxD;aAFUD,uBAAuB,GAAvBA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAM,QACFC,KAAe,EACfC,KAAkB,EACgC;QAClD,IAAI;YAEA,MAAMC,eAAe,MAAM,IAAI,CAAC,uBAAuB,CAAIF,OAAOC;YAGlE,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAAID,OAAO;gBAClDC;gBACAC;YACJ;YAEA,OAAOC,OAAO,EAAE;QACpB,EAAE,OAAOC,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,sBAAsBD;QACjD;IACJ;AACJ;AAEO,MAAME,8CAAwBC,qBAAqB;IACtD,aAAaC;IACb,gBAAgBX;IAChB,cAAc;QAACY;QAAyBC;KAAkB;AAC9D"}

package/features/contentEntry/UpdateEntry/UpdateEntryUseCase.d.ts

@@ -1,35 +1,18 @@
 import { Result } from "@webiny/feature/api";
-import { UpdateEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
-import { UpdateEntryRepository } from "./abstractions.js";
-import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { UpdateEntryRepository, UpdateEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
 import { AccessControl } from "../../../features/shared/abstractions.js";
-import { CmsContext } from "../../../features/shared/abstractions.js";
-import { TenantContext } from "@webiny/api-core/features/TenantContext";
-import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
 import { GetRevisionByIdUseCase } from "../../../features/contentEntry/GetRevisionById/abstractions.js";
 import type { CmsEntry, CmsEntryValues, CmsModel, UpdateCmsEntryInput, UpdateCmsEntryOptionsInput } from "../../../types/index.js";
-import type { GenericRecord } from "@webiny/api/types.js";
-/**
- * UpdateEntryUseCase - Orchestrates entry updates.
- *
- * Responsibilities:
- * - Fetch original entry
- * - Validate entry is not locked
- * - Transform raw input to updated domain entry
- * - Apply access control
- * - Publish domain events
- * - Delegate persistence to repository
- */
+import { UpdateEntryDataFactory } from "../../../features/contentEntry/entryDataFactories/UpdateEntryDataFactory/index.js";
 declare class UpdateEntryUseCaseImpl implements UseCaseAbstraction.Interface {
     private eventPublisher;
     private repository;
     private accessControl;
-    private cmsContext;
-    private tenantContext;
-    private identityContext;
     private getRevisionByIdUseCase;
-    constructor(eventPublisher: EventPublisher.Interface, repository: UpdateEntryRepository.Interface, accessControl: AccessControl.Interface, cmsContext: CmsContext.Interface, tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface, getRevisionByIdUseCase: GetRevisionByIdUseCase.Interface);
-    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string, rawInput: UpdateCmsEntryInput<T>, metaInput?: GenericRecord, options?: UpdateCmsEntryOptionsInput): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+    private updateEntryDataFactory;
+    constructor(eventPublisher: EventPublisher.Interface, repository: UpdateEntryRepository.Interface, accessControl: AccessControl.Interface, getRevisionByIdUseCase: GetRevisionByIdUseCase.Interface, updateEntryDataFactory: UpdateEntryDataFactory.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, id: string, rawInput: UpdateCmsEntryInput<T>, options?: UpdateCmsEntryOptionsInput): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
 }
 export declare const UpdateEntryUseCase: import("@webiny/di").Implementation<typeof UpdateEntryUseCaseImpl>;
 export {};