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

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","EventPublisher","DeleteMultipleEntriesUseCase","UseCaseAbstraction","DeleteMultipleEntriesRepository","AccessControl","ListEntriesUseCase","EntryBeforeDeleteMultipleEvent","EntryAfterDeleteMultipleEvent","EntryDeleteMultipleErrorEvent","EntryNotAuthorizedError","parseIdentifier","WebinyError","filterAsync","DeleteMultipleEntriesUseCaseImpl","constructor","repository","accessControl","listEntries","eventPublisher","execute","model","params","entries","input","maxDeletableEntries","entryIdList","Set","id","entryId","add","ids","Array","from","length","fail","canAccess","canAccessEntry","rwd","fromModel","listResult","where","latest","entryId_in","limit","isFail","error","value","accessibleEntries","entry","items","map","publish","result","ok","abstraction","implementation","dependencies"],"sources":["DeleteMultipleEntriesUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport { DeleteMultipleEntriesUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { DeleteMultipleEntriesRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { ListEntriesUseCase } from \"~/features/contentEntry/ListEntries/abstractions.js\";\nimport type { CmsModel } from \"~/types/index.js\";\nimport {\n    EntryBeforeDeleteMultipleEvent,\n    EntryAfterDeleteMultipleEvent,\n    EntryDeleteMultipleErrorEvent\n} from \"./events.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport WebinyError from \"@webiny/error\";\nimport { filterAsync } from \"~/utils/filterAsync.js\";\n\n/**\n * DeleteMultipleEntriesUseCase - Orchestrates deleting multiple entries.\n *\n * Responsibilities:\n * - Validate max entries limit (50)\n * - Parse entry IDs to unique entry IDs\n * - Apply access control\n * - Fetch entries using ListEntries use case\n * - Filter entries by access control\n * - Publish domain events\n * - Delegate to repository for storage operations\n */\nclass DeleteMultipleEntriesUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: DeleteMultipleEntriesRepository.Interface,\n        private accessControl: AccessControl.Interface,\n        private listEntries: ListEntriesUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(\n        model: CmsModel,\n        params: { entries: string[] }\n    ): Promise<Result<Array<{ id: string }>, UseCaseAbstraction.Error>> {\n        const { entries: input } = params;\n        const maxDeletableEntries = 50;\n\n        // Parse entry IDs to unique entry IDs\n        const entryIdList = new Set<string>();\n        for (const id of input) {\n            const { id: entryId } = parseIdentifier(id);\n            entryIdList.add(entryId);\n        }\n        const ids = Array.from(entryIdList);\n\n        // Validate max entries limit\n        if (ids.length > maxDeletableEntries) {\n            return Result.fail(\n                new WebinyError(\n                    \"Cannot delete more than 50 entries at once.\",\n                    \"DELETE_ENTRIES_MAX\",\n                    {\n                        entries: ids\n                    }\n                ) as any\n            );\n        }\n\n        // Check access control\n        const canAccess = await this.accessControl.canAccessEntry({ model, rwd: \"d\" });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Fetch entries using ListEntries use case\n        const listResult = await this.listEntries.execute(model, {\n            where: {\n                latest: true,\n                entryId_in: ids\n            },\n            limit: maxDeletableEntries + 1\n        });\n\n        if (listResult.isFail()) {\n            return Result.fail(listResult.error);\n        }\n\n        const { entries } = listResult.value;\n\n        // Filter entries by access control (only delete entries user can access)\n        const accessibleEntries = await filterAsync(entries, async entry => {\n            return this.accessControl.canAccessEntry({ model, entry });\n        });\n\n        const items = accessibleEntries.map(entry => entry.id);\n\n        try {\n            // Publish before event\n            await this.eventPublisher.publish(\n                new EntryBeforeDeleteMultipleEvent({\n                    entries,\n                    ids,\n                    model\n                })\n            );\n\n            // Delegate to repository\n            const result = await this.repository.execute(model, items);\n\n            if (result.isFail()) {\n                await this.eventPublisher.publish(\n                    new EntryDeleteMultipleErrorEvent({\n                        entries,\n                        ids,\n                        model,\n                        error: result.error\n                    })\n                );\n                return Result.fail(result.error);\n            }\n\n            // Publish after event\n            await this.eventPublisher.publish(\n                new EntryAfterDeleteMultipleEvent({\n                    entries,\n                    ids,\n                    model\n                })\n            );\n\n            return Result.ok(\n                items.map(id => {\n                    return { id };\n                })\n            );\n        } catch (error) {\n            await this.eventPublisher.publish(\n                new EntryDeleteMultipleErrorEvent({\n                    entries,\n                    ids,\n                    model,\n                    error: error as Error\n                })\n            );\n            return Result.fail(error as any);\n        }\n    }\n}\n\nexport const DeleteMultipleEntriesUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: DeleteMultipleEntriesUseCaseImpl,\n    dependencies: [\n        DeleteMultipleEntriesRepository,\n        AccessControl,\n        ListEntriesUseCase,\n        EventPublisher\n    ]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,68 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * DeleteMultipleEntries Use Case - Deletes multiple entries at once.
+ */
+export interface IDeleteMultipleEntriesUseCaseResultItem {
+    id: string;
+}
+export interface IDeleteMultipleEntriesUseCaseParams {
+    entries: string[];
+}
+export interface IDeleteMultipleEntriesUseCase {
+    execute(model: CmsModel, params: IDeleteMultipleEntriesUseCaseParams): Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;
+}
+export interface IDeleteMultipleEntriesUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IDeleteMultipleEntriesUseCaseErrors[keyof IDeleteMultipleEntriesUseCaseErrors];
+export declare const DeleteMultipleEntriesUseCase: import("@webiny/di").Abstraction<IDeleteMultipleEntriesUseCase>;
+export declare namespace DeleteMultipleEntriesUseCase {
+    type Interface = IDeleteMultipleEntriesUseCase;
+    type Params = IDeleteMultipleEntriesUseCaseParams;
+    type Error = UseCaseError;
+    type Return = Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;
+}
+/**
+ * Payload for before delete multiple event
+ */
+export interface EntryBeforeDeleteMultipleEventPayload {
+    entries: CmsEntry[];
+    ids: string[];
+    model: CmsModel;
+}
+/**
+ * Payload for after delete multiple event
+ */
+export interface EntryAfterDeleteMultipleEventPayload {
+    entries: CmsEntry[];
+    ids: string[];
+    model: CmsModel;
+}
+/**
+ * Payload for delete multiple error event
+ */
+export interface EntryDeleteMultipleErrorEventPayload {
+    entries: CmsEntry[];
+    ids: string[];
+    model: CmsModel;
+    error: Error;
+}
+/**
+ * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.
+ */
+export interface IDeleteMultipleEntriesRepository {
+    execute(model: CmsModel, entryIds: string[]): Promise<Result<void, RepositoryError>>;
+}
+export interface IDeleteMultipleEntriesRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IDeleteMultipleEntriesRepositoryErrors[keyof IDeleteMultipleEntriesRepositoryErrors];
+export declare const DeleteMultipleEntriesRepository: import("@webiny/di").Abstraction<IDeleteMultipleEntriesRepository>;
+export declare namespace DeleteMultipleEntriesRepository {
+    type Interface = IDeleteMultipleEntriesRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/DeleteMultipleEntries/abstractions.js

@@ -0,0 +1,27 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * DeleteMultipleEntries Use Case - Deletes multiple entries at once.
+ */
+
+export const DeleteMultipleEntriesUseCase = createAbstraction("DeleteMultipleEntriesUseCase");
+
+/**
+ * Payload for before delete multiple event
+ */
+
+/**
+ * Payload for after delete multiple event
+ */
+
+/**
+ * Payload for delete multiple error event
+ */
+
+/**
+ * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.
+ */
+
+export const DeleteMultipleEntriesRepository = createAbstraction("DeleteMultipleEntriesRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DeleteMultipleEntriesUseCase","DeleteMultipleEntriesRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsModel } from \"~/types/index.js\";\nimport type {\n    EntryNotAuthorizedError,\n    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * DeleteMultipleEntries Use Case - Deletes multiple entries at once.\n */\n\nexport interface IDeleteMultipleEntriesUseCaseResultItem {\n    id: string;\n}\nexport interface IDeleteMultipleEntriesUseCaseParams {\n    entries: string[];\n}\nexport interface IDeleteMultipleEntriesUseCase {\n    execute(\n        model: CmsModel,\n        params: IDeleteMultipleEntriesUseCaseParams\n    ): Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;\n}\n\nexport interface IDeleteMultipleEntriesUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IDeleteMultipleEntriesUseCaseErrors[keyof IDeleteMultipleEntriesUseCaseErrors];\n\nexport const DeleteMultipleEntriesUseCase = createAbstraction<IDeleteMultipleEntriesUseCase>(\n    \"DeleteMultipleEntriesUseCase\"\n);\n\nexport namespace DeleteMultipleEntriesUseCase {\n    export type Interface = IDeleteMultipleEntriesUseCase;\n    export type Params = IDeleteMultipleEntriesUseCaseParams;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<IDeleteMultipleEntriesUseCaseResultItem[], UseCaseError>>;\n}\n\n/**\n * Payload for before delete multiple event\n */\nexport interface EntryBeforeDeleteMultipleEventPayload {\n    entries: CmsEntry[];\n    ids: string[];\n    model: CmsModel;\n}\n\n/**\n * Payload for after delete multiple event\n */\nexport interface EntryAfterDeleteMultipleEventPayload {\n    entries: CmsEntry[];\n    ids: string[];\n    model: CmsModel;\n}\n\n/**\n * Payload for delete multiple error event\n */\nexport interface EntryDeleteMultipleErrorEventPayload {\n    entries: CmsEntry[];\n    ids: string[];\n    model: CmsModel;\n    error: Error;\n}\n\n/**\n * DeleteMultipleEntriesRepository - Handles storage operations for deleting multiple entries.\n */\nexport interface IDeleteMultipleEntriesRepository {\n    execute(model: CmsModel, entryIds: string[]): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IDeleteMultipleEntriesRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError =\n    IDeleteMultipleEntriesRepositoryErrors[keyof IDeleteMultipleEntriesRepositoryErrors];\n\nexport const DeleteMultipleEntriesRepository = createAbstraction<IDeleteMultipleEntriesRepository>(\n    \"DeleteMultipleEntriesRepository\"\n);\n\nexport namespace DeleteMultipleEntriesRepository {\n    export type Interface = IDeleteMultipleEntriesRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAO/D;AACA;AACA;;AAsBA,OAAO,MAAMC,4BAA4B,GAAGD,iBAAiB,CACzD,8BACJ,CAAC;;AAUD;AACA;AACA;;AAOA;AACA;AACA;;AAOA;AACA;AACA;;AAQA;AACA;AACA;;AAYA,OAAO,MAAME,+BAA+B,GAAGF,iBAAiB,CAC5D,iCACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,39 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { EntryAfterDeleteMultipleEventPayload, EntryBeforeDeleteMultipleEventPayload, EntryDeleteMultipleErrorEventPayload } from "./abstractions.js";
+/**
+ * Before delete multiple entries event
+ */
+export declare class EntryBeforeDeleteMultipleEvent extends DomainEvent<EntryBeforeDeleteMultipleEventPayload> {
+    eventType: "Cms/Entry/BeforeDeleteMultiple";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeDeleteMultipleEvent>>;
+}
+export declare const EntryBeforeDeleteMultipleEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeDeleteMultipleEvent>>;
+export declare namespace EntryBeforeDeleteMultipleEventHandler {
+    type Interface = IEventHandler<EntryBeforeDeleteMultipleEvent>;
+    type Event = EntryBeforeDeleteMultipleEvent;
+}
+/**
+ * After delete multiple entries event
+ */
+export declare class EntryAfterDeleteMultipleEvent extends DomainEvent<EntryAfterDeleteMultipleEventPayload> {
+    eventType: "Cms/Entry/AfterDeleteMultiple";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterDeleteMultipleEvent>>;
+}
+export declare const EntryAfterDeleteMultipleEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterDeleteMultipleEvent>>;
+export declare namespace EntryAfterDeleteMultipleEventHandler {
+    type Interface = IEventHandler<EntryAfterDeleteMultipleEvent>;
+    type Event = EntryAfterDeleteMultipleEvent;
+}
+/**
+ * Delete multiple entries error event
+ */
+export declare class EntryDeleteMultipleErrorEvent extends DomainEvent<EntryDeleteMultipleErrorEventPayload> {
+    eventType: "Cms/Entry/DeleteMultipleError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryDeleteMultipleErrorEvent>>;
+}
+export declare const EntryDeleteMultipleErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryDeleteMultipleErrorEvent>>;
+export declare namespace EntryDeleteMultipleErrorEventHandler {
+    type Interface = IEventHandler<EntryDeleteMultipleErrorEvent>;
+    type Event = EntryDeleteMultipleErrorEvent;
+}

package/features/contentEntry/DeleteMultipleEntries/events.js

@@ -0,0 +1,34 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+/**
+ * Before delete multiple entries event
+ */
+export class EntryBeforeDeleteMultipleEvent extends DomainEvent {
+  eventType = "Cms/Entry/BeforeDeleteMultiple";
+  getHandlerAbstraction() {
+    return EntryBeforeDeleteMultipleEventHandler;
+  }
+}
+export const EntryBeforeDeleteMultipleEventHandler = createAbstraction("EntryBeforeDeleteMultipleEventHandler");
+/**
+ * After delete multiple entries event
+ */
+export class EntryAfterDeleteMultipleEvent extends DomainEvent {
+  eventType = "Cms/Entry/AfterDeleteMultiple";
+  getHandlerAbstraction() {
+    return EntryAfterDeleteMultipleEventHandler;
+  }
+}
+export const EntryAfterDeleteMultipleEventHandler = createAbstraction("EntryAfterDeleteMultipleEventHandler");
+/**
+ * Delete multiple entries error event
+ */
+export class EntryDeleteMultipleErrorEvent extends DomainEvent {
+  eventType = "Cms/Entry/DeleteMultipleError";
+  getHandlerAbstraction() {
+    return EntryDeleteMultipleErrorEventHandler;
+  }
+}
+export const EntryDeleteMultipleErrorEventHandler = createAbstraction("EntryDeleteMultipleErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforeDeleteMultipleEvent","eventType","getHandlerAbstraction","EntryBeforeDeleteMultipleEventHandler","EntryAfterDeleteMultipleEvent","EntryAfterDeleteMultipleEventHandler","EntryDeleteMultipleErrorEvent","EntryDeleteMultipleErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type {\n    EntryAfterDeleteMultipleEventPayload,\n    EntryBeforeDeleteMultipleEventPayload,\n    EntryDeleteMultipleErrorEventPayload\n} from \"./abstractions.js\";\n\n/**\n * Before delete multiple entries event\n */\nexport class EntryBeforeDeleteMultipleEvent extends DomainEvent<EntryBeforeDeleteMultipleEventPayload> {\n    eventType = \"Cms/Entry/BeforeDeleteMultiple\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeDeleteMultipleEventHandler;\n    }\n}\n\nexport const EntryBeforeDeleteMultipleEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeDeleteMultipleEvent>\n>(\"EntryBeforeDeleteMultipleEventHandler\");\n\nexport namespace EntryBeforeDeleteMultipleEventHandler {\n    export type Interface = IEventHandler<EntryBeforeDeleteMultipleEvent>;\n    export type Event = EntryBeforeDeleteMultipleEvent;\n}\n\n/**\n * After delete multiple entries event\n */\nexport class EntryAfterDeleteMultipleEvent extends DomainEvent<EntryAfterDeleteMultipleEventPayload> {\n    eventType = \"Cms/Entry/AfterDeleteMultiple\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterDeleteMultipleEventHandler;\n    }\n}\n\nexport const EntryAfterDeleteMultipleEventHandler = createAbstraction<\n    IEventHandler<EntryAfterDeleteMultipleEvent>\n>(\"EntryAfterDeleteMultipleEventHandler\");\n\nexport namespace EntryAfterDeleteMultipleEventHandler {\n    export type Interface = IEventHandler<EntryAfterDeleteMultipleEvent>;\n    export type Event = EntryAfterDeleteMultipleEvent;\n}\n\n/**\n * Delete multiple entries error event\n */\nexport class EntryDeleteMultipleErrorEvent extends DomainEvent<EntryDeleteMultipleErrorEventPayload> {\n    eventType = \"Cms/Entry/DeleteMultipleError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryDeleteMultipleErrorEventHandler;\n    }\n}\n\nexport const EntryDeleteMultipleErrorEventHandler = createAbstraction<\n    IEventHandler<EntryDeleteMultipleErrorEvent>\n>(\"EntryDeleteMultipleErrorEventHandler\");\n\nexport namespace EntryDeleteMultipleErrorEventHandler {\n    export type Interface = IEventHandler<EntryDeleteMultipleErrorEvent>;\n    export type Event = EntryDeleteMultipleErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;AAOtE;AACA;AACA;AACA,OAAO,MAAMC,8BAA8B,SAASD,WAAW,CAAwC;EACnGE,SAAS,GAAG,gCAAgC;EAE5CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,qCAAqC;EAChD;AACJ;AAEA,OAAO,MAAMA,qCAAqC,GAAGL,iBAAiB,CAEpE,uCAAuC,CAAC;AAO1C;AACA;AACA;AACA,OAAO,MAAMM,6BAA6B,SAASL,WAAW,CAAuC;EACjGE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,oCAAoC;EAC/C;AACJ;AAEA,OAAO,MAAMA,oCAAoC,GAAGP,iBAAiB,CAEnE,sCAAsC,CAAC;AAOzC;AACA;AACA;AACA,OAAO,MAAMQ,6BAA6B,SAASP,WAAW,CAAuC;EACjGE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,oCAAoC;EAC/C;AACJ;AAEA,OAAO,MAAMA,oCAAoC,GAAGT,iBAAiB,CAEnE,sCAAsC,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/DeleteMultipleEntries/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","DeleteMultipleEntriesUseCase","DeleteMultipleEntriesRepository","DeleteMultipleEntriesFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteMultipleEntriesUseCase } from \"./DeleteMultipleEntriesUseCase.js\";\nimport { DeleteMultipleEntriesRepository } from \"./DeleteMultipleEntriesRepository.js\";\n\nexport const DeleteMultipleEntriesFeature = createFeature({\n    name: \"DeleteMultipleEntries\",\n    register(container) {\n        // Register repository (singleton scope)\n        container.register(DeleteMultipleEntriesRepository).inSingletonScope();\n\n        // Register use case (transient scope)\n        container.register(DeleteMultipleEntriesUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,4BAA4B;AACrC,SAASC,+BAA+B;AAExC,OAAO,MAAMC,4BAA4B,GAAGH,aAAa,CAAC;EACtDI,IAAI,EAAE,uBAAuB;EAC7BC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,+BAA+B,CAAC,CAACK,gBAAgB,CAAC,CAAC;;IAEtE;IACAD,SAAS,CAACD,QAAQ,CAACJ,4BAA4B,CAAC;EACpD;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { DeleteMultipleEntriesRepository, DeleteMultipleEntriesUseCase } from "./abstractions.js";
+export { EntryAfterDeleteMultipleEventHandler, EntryBeforeDeleteMultipleEventHandler } from "./events.js";

package/features/contentEntry/DeleteMultipleEntries/index.js

@@ -0,0 +1,4 @@
+export { DeleteMultipleEntriesRepository, DeleteMultipleEntriesUseCase } from "./abstractions.js";
+export { EntryAfterDeleteMultipleEventHandler, EntryBeforeDeleteMultipleEventHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["DeleteMultipleEntriesRepository","DeleteMultipleEntriesUseCase","EntryAfterDeleteMultipleEventHandler","EntryBeforeDeleteMultipleEventHandler"],"sources":["index.ts"],"sourcesContent":["export { DeleteMultipleEntriesRepository, DeleteMultipleEntriesUseCase } from \"./abstractions.js\";\nexport {\n    EntryAfterDeleteMultipleEventHandler,\n    EntryBeforeDeleteMultipleEventHandler\n} from \"./events.js\";\n"],"mappings":"AAAA,SAASA,+BAA+B,EAAEC,4BAA4B;AACtE,SACIC,oCAAoC,EACpCC,qCAAqC","ignoreList":[]}

package/features/contentEntry/GetEntriesByIds/GetEntriesByIdsRepository.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntriesByIdsRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import { StorageOperations } from "../../../features/shared/abstractions.js";
+import { EntryFromStorageTransform } from "../../../legacy/abstractions.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+/**
+ * GetEntriesByIdsRepository - Fetches entries by IDs from storage and transforms them.
+ * Returns array of entries.
+ */
+declare class GetEntriesByIdsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private tenantContext;
+    private entryFromStorageTransform;
+    private storageOperations;
+    constructor(tenantContext: TenantContext.Interface, entryFromStorageTransform: EntryFromStorageTransform.Interface, storageOperations: StorageOperations.Interface);
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], RepositoryAbstraction.Error>>;
+}
+export declare const GetEntriesByIdsRepository: import("@webiny/di").Implementation<typeof GetEntriesByIdsRepositoryImpl>;
+export {};

package/features/contentEntry/GetEntriesByIds/GetEntriesByIdsRepository.js

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { GetEntriesByIdsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryFromStorageTransform } from "../../../legacy/abstractions.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+
+/**
+ * GetEntriesByIdsRepository - Fetches entries by IDs from storage and transforms them.
+ * Returns array of entries.
+ */
+class GetEntriesByIdsRepositoryImpl {
+  constructor(tenantContext, entryFromStorageTransform, storageOperations) {
+    this.tenantContext = tenantContext;
+    this.entryFromStorageTransform = entryFromStorageTransform;
+    this.storageOperations = storageOperations;
+  }
+  async execute(model, ids) {
+    try {
+      const modelWithTenant = {
+        ...model,
+        tenant: this.tenantContext.getTenant().id
+      };
+      const result = await this.storageOperations.entries.getByIds(modelWithTenant, {
+        ids
+      });
+
+      // Transform storage entries to domain entries
+      const items = await Promise.all(result.map(async entry => {
+        return this.entryFromStorageTransform(model, entry);
+      }));
+      return Result.ok(items);
+    } catch (error) {
+      return Result.fail(new EntryPersistenceError(error));
+    }
+  }
+}
+export const GetEntriesByIdsRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: GetEntriesByIdsRepositoryImpl,
+  dependencies: [TenantContext, EntryFromStorageTransform, StorageOperations]
+});
+
+//# sourceMappingURL=GetEntriesByIdsRepository.js.map

package/features/contentEntry/GetEntriesByIds/GetEntriesByIdsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","GetEntriesByIdsRepository","RepositoryAbstraction","EntryPersistenceError","StorageOperations","EntryFromStorageTransform","TenantContext","GetEntriesByIdsRepositoryImpl","constructor","tenantContext","entryFromStorageTransform","storageOperations","execute","model","ids","modelWithTenant","tenant","getTenant","id","result","entries","getByIds","items","Promise","all","map","entry","ok","error","fail","abstraction","implementation","dependencies"],"sources":["GetEntriesByIdsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { GetEntriesByIdsRepository 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 { EntryFromStorageTransform } from \"~/legacy/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\n\n/**\n * GetEntriesByIdsRepository - Fetches entries by IDs from storage and transforms them.\n * Returns array of entries.\n */\nclass GetEntriesByIdsRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private tenantContext: TenantContext.Interface,\n        private entryFromStorageTransform: EntryFromStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], RepositoryAbstraction.Error>> {\n        try {\n            const modelWithTenant = { ...model, tenant: this.tenantContext.getTenant().id };\n            const result = await this.storageOperations.entries.getByIds<T>(modelWithTenant, {\n                ids\n            });\n\n            // Transform storage entries to domain entries\n            const items = await Promise.all(\n                result.map(async entry => {\n                    return this.entryFromStorageTransform(model, entry);\n                })\n            );\n\n            return Result.ok(items);\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const GetEntriesByIdsRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: GetEntriesByIdsRepositoryImpl,\n    dependencies: [TenantContext, EntryFromStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,yBAAyB,IAAIC,qBAAqB;AAC3D,SAASC,qBAAqB;AAE9B,SAASC,iBAAiB;AAC1B,SAASC,yBAAyB;AAClC,SAASC,aAAa,QAAQ,yCAAyC;;AAEvE;AACA;AACA;AACA;AACA,MAAMC,6BAA6B,CAA4C;EACpEC,WAAWA,CACNC,aAAsC,EACtCC,yBAA8D,EAC9DC,iBAA8C,EACxD;IAAA,KAHUF,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,yBAA8D,GAA9DA,yBAA8D;IAAA,KAC9DC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAMC,OAAOA,CACTC,KAAe,EACfC,GAAa,EAC8C;IAC3D,IAAI;MACA,MAAMC,eAAe,GAAG;QAAE,GAAGF,KAAK;QAAEG,MAAM,EAAE,IAAI,CAACP,aAAa,CAACQ,SAAS,CAAC,CAAC,CAACC;MAAG,CAAC;MAC/E,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACR,iBAAiB,CAACS,OAAO,CAACC,QAAQ,CAAIN,eAAe,EAAE;QAC7ED;MACJ,CAAC,CAAC;;MAEF;MACA,MAAMQ,KAAK,GAAG,MAAMC,OAAO,CAACC,GAAG,CAC3BL,MAAM,CAACM,GAAG,CAAC,MAAMC,KAAK,IAAI;QACtB,OAAO,IAAI,CAAChB,yBAAyB,CAACG,KAAK,EAAEa,KAAK,CAAC;MACvD,CAAC,CACL,CAAC;MAED,OAAO3B,MAAM,CAAC4B,EAAE,CAACL,KAAK,CAAC;IAC3B,CAAC,CAAC,OAAOM,KAAK,EAAE;MACZ,OAAO7B,MAAM,CAAC8B,IAAI,CAAC,IAAI1B,qBAAqB,CAACyB,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAM3B,yBAAyB,GAAGD,oBAAoB,CAAC;EAC1D8B,WAAW,EAAE5B,qBAAqB;EAClC6B,cAAc,EAAExB,6BAA6B;EAC7CyB,YAAY,EAAE,CAAC1B,aAAa,EAAED,yBAAyB,EAAED,iBAAiB;AAC9E,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetEntriesByIds/GetEntriesByIdsUseCase.d.ts

@@ -0,0 +1,20 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntriesByIdsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetEntriesByIdsRepository } from "./abstractions.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * GetEntriesByIdsUseCase - Orchestrates fetching entries by IDs with access control.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Delegate to repository for data fetching
+ */
+declare class GetEntriesByIdsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private accessControl;
+    constructor(repository: GetEntriesByIdsRepository.Interface, accessControl: AccessControl.Interface);
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], UseCaseAbstraction.Error>>;
+}
+export declare const GetEntriesByIdsUseCase: import("@webiny/di").Implementation<typeof GetEntriesByIdsUseCaseImpl>;
+export {};

package/features/contentEntry/GetEntriesByIds/GetEntriesByIdsUseCase.js

@@ -0,0 +1,43 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { GetEntriesByIdsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetEntriesByIdsRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * GetEntriesByIdsUseCase - Orchestrates fetching entries by IDs with access control.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Delegate to repository for data fetching
+ */
+class GetEntriesByIdsUseCaseImpl {
+  constructor(repository, accessControl) {
+    this.repository = repository;
+    this.accessControl = accessControl;
+  }
+  async execute(model, ids) {
+    // Check access control
+    const canAccess = await this.accessControl.canAccessEntry({
+      model
+    });
+    if (!canAccess) {
+      return Result.fail(EntryNotAuthorizedError.fromModel(model));
+    }
+
+    // Delegate to repository
+    const result = await this.repository.execute(model, ids);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    return Result.ok(result.value);
+  }
+}
+export const GetEntriesByIdsUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: GetEntriesByIdsUseCaseImpl,
+  dependencies: [GetEntriesByIdsRepository, AccessControl]
+});
+
+//# sourceMappingURL=GetEntriesByIdsUseCase.js.map

package/features/contentEntry/GetEntriesByIds/GetEntriesByIdsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","GetEntriesByIdsUseCase","UseCaseAbstraction","GetEntriesByIdsRepository","AccessControl","EntryNotAuthorizedError","GetEntriesByIdsUseCaseImpl","constructor","repository","accessControl","execute","model","ids","canAccess","canAccessEntry","fail","fromModel","result","isFail","error","ok","value","abstraction","implementation","dependencies"],"sources":["GetEntriesByIdsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { GetEntriesByIdsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetEntriesByIdsRepository } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * GetEntriesByIdsUseCase - Orchestrates fetching entries by IDs with access control.\n *\n * Responsibilities:\n * - Apply access control\n * - Delegate to repository for data fetching\n */\nclass GetEntriesByIdsUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: GetEntriesByIdsRepository.Interface,\n        private accessControl: AccessControl.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], UseCaseAbstraction.Error>> {\n        // Check access control\n        const canAccess = await this.accessControl.canAccessEntry({ model });\n        if (!canAccess) {\n            return Result.fail(EntryNotAuthorizedError.fromModel(model));\n        }\n\n        // Delegate to repository\n        const result = await this.repository.execute<T>(model, ids);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const GetEntriesByIdsUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetEntriesByIdsUseCaseImpl,\n    dependencies: [GetEntriesByIdsRepository, AccessControl]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,sBAAsB,IAAIC,kBAAkB;AACrD,SAASC,yBAAyB;AAClC,SAASC,aAAa;AAEtB,SAASC,uBAAuB;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,0BAA0B,CAAyC;EAC9DC,WAAWA,CACNC,UAA+C,EAC/CC,aAAsC,EAChD;IAAA,KAFUD,UAA+C,GAA/CA,UAA+C;IAAA,KAC/CC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CACTC,KAAe,EACfC,GAAa,EAC2C;IACxD;IACA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACK,cAAc,CAAC;MAAEH;IAAM,CAAC,CAAC;IACpE,IAAI,CAACE,SAAS,EAAE;MACZ,OAAOd,MAAM,CAACgB,IAAI,CAACV,uBAAuB,CAACW,SAAS,CAACL,KAAK,CAAC,CAAC;IAChE;;IAEA;IACA,MAAMM,MAAM,GAAG,MAAM,IAAI,CAACT,UAAU,CAACE,OAAO,CAAIC,KAAK,EAAEC,GAAG,CAAC;IAE3D,IAAIK,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOnB,MAAM,CAACgB,IAAI,CAACE,MAAM,CAACE,KAAK,CAAC;IACpC;IAEA,OAAOpB,MAAM,CAACqB,EAAE,CAACH,MAAM,CAACI,KAAK,CAAC;EAClC;AACJ;AAEA,OAAO,MAAMpB,sBAAsB,GAAGD,oBAAoB,CAAC;EACvDsB,WAAW,EAAEpB,kBAAkB;EAC/BqB,cAAc,EAAEjB,0BAA0B;EAC1CkB,YAAY,EAAE,CAACrB,yBAAyB,EAAEC,aAAa;AAC3D,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * GetEntriesByIds Use Case - Fetches multiple entries by their exact revision IDs.
+ * Returns array of entries (excludes deleted entries via decorator).
+ */
+export interface IGetEntriesByIdsUseCase {
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], UseCaseError>>;
+}
+export interface IGetEntriesByIdsUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IGetEntriesByIdsUseCaseErrors[keyof IGetEntriesByIdsUseCaseErrors];
+export declare const GetEntriesByIdsUseCase: import("@webiny/di").Abstraction<IGetEntriesByIdsUseCase>;
+export declare namespace GetEntriesByIdsUseCase {
+    type Interface = IGetEntriesByIdsUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>[], UseCaseError>>;
+}
+/**
+ * GetEntriesByIdsRepository - Fetches entries from storage by IDs and transforms them.
+ */
+export interface IGetEntriesByIdsRepository {
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], RepositoryError>>;
+}
+export interface IGetEntriesByIdsRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IGetEntriesByIdsRepositoryErrors[keyof IGetEntriesByIdsRepositoryErrors];
+export declare const GetEntriesByIdsRepository: import("@webiny/di").Abstraction<IGetEntriesByIdsRepository>;
+export declare namespace GetEntriesByIdsRepository {
+    type Interface = IGetEntriesByIdsRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/GetEntriesByIds/abstractions.js

@@ -0,0 +1,16 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetEntriesByIds Use Case - Fetches multiple entries by their exact revision IDs.
+ * Returns array of entries (excludes deleted entries via decorator).
+ */
+
+export const GetEntriesByIdsUseCase = createAbstraction("GetEntriesByIdsUseCase");
+
+/**
+ * GetEntriesByIdsRepository - Fetches entries from storage by IDs and transforms them.
+ */
+
+export const GetEntriesByIdsRepository = createAbstraction("GetEntriesByIdsRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetEntriesByIdsUseCase","GetEntriesByIdsRepository"],"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    EntryPersistenceError\n} from \"~/domain/contentEntry/errors.js\";\n\n/**\n * GetEntriesByIds Use Case - Fetches multiple entries by their exact revision IDs.\n * Returns array of entries (excludes deleted entries via decorator).\n */\nexport interface IGetEntriesByIdsUseCase {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], UseCaseError>>;\n}\n\nexport interface IGetEntriesByIdsUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError = IGetEntriesByIdsUseCaseErrors[keyof IGetEntriesByIdsUseCaseErrors];\n\nexport const GetEntriesByIdsUseCase =\n    createAbstraction<IGetEntriesByIdsUseCase>(\"GetEntriesByIdsUseCase\");\n\nexport namespace GetEntriesByIdsUseCase {\n    export type Interface = IGetEntriesByIdsUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>[], UseCaseError>>;\n}\n\n/**\n * GetEntriesByIdsRepository - Fetches entries from storage by IDs and transforms them.\n */\nexport interface IGetEntriesByIdsRepository {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], RepositoryError>>;\n}\n\nexport interface IGetEntriesByIdsRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError = IGetEntriesByIdsRepositoryErrors[keyof IGetEntriesByIdsRepositoryErrors];\n\nexport const GetEntriesByIdsRepository = createAbstraction<IGetEntriesByIdsRepository>(\n    \"GetEntriesByIdsRepository\"\n);\n\nexport namespace GetEntriesByIdsRepository {\n    export type Interface = IGetEntriesByIdsRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAO/D;AACA;AACA;AACA;;AAeA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAQxE;AACA;AACA;;AAcA,OAAO,MAAME,yBAAyB,GAAGF,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}

package/features/contentEntry/GetEntriesByIds/decorators/GetEntriesByIdsNotDeletedDecorator.d.ts

@@ -0,0 +1,16 @@
+import { GetEntriesByIdsUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../../types/index.js";
+/**
+ * GetEntriesByIdsNotDeletedDecorator - Filters out deleted entries.
+ *
+ * This decorator wraps the GetEntriesByIdsUseCase and filters out
+ * entries marked as deleted (wbyDeleted flag).
+ */
+declare class GetEntriesByIdsNotDeletedDecoratorImpl implements GetEntriesByIdsUseCase.Interface {
+    private decoratee;
+    constructor(decoratee: GetEntriesByIdsUseCase.Interface);
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], GetEntriesByIdsUseCase.Error>>;
+}
+export declare const GetEntriesByIdsNotDeletedDecorator: typeof GetEntriesByIdsNotDeletedDecoratorImpl;
+export {};

package/features/contentEntry/GetEntriesByIds/decorators/GetEntriesByIdsNotDeletedDecorator.js

@@ -0,0 +1,32 @@
+import { createDecorator } from "@webiny/feature/api";
+import { GetEntriesByIdsUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+/**
+ * GetEntriesByIdsNotDeletedDecorator - Filters out deleted entries.
+ *
+ * This decorator wraps the GetEntriesByIdsUseCase and filters out
+ * entries marked as deleted (wbyDeleted flag).
+ */
+class GetEntriesByIdsNotDeletedDecoratorImpl {
+  constructor(decoratee) {
+    this.decoratee = decoratee;
+  }
+  async execute(model, ids) {
+    const result = await this.decoratee.execute(model, ids);
+    if (result.isFail()) {
+      return result;
+    }
+    const entries = result.value;
+
+    // Filter out deleted entries
+    const nonDeletedEntries = entries.filter(entry => !entry.wbyDeleted);
+    return Result.ok(nonDeletedEntries);
+  }
+}
+export const GetEntriesByIdsNotDeletedDecorator = createDecorator({
+  abstraction: GetEntriesByIdsUseCase,
+  decorator: GetEntriesByIdsNotDeletedDecoratorImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=GetEntriesByIdsNotDeletedDecorator.js.map

package/features/contentEntry/GetEntriesByIds/decorators/GetEntriesByIdsNotDeletedDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createDecorator","GetEntriesByIdsUseCase","Result","GetEntriesByIdsNotDeletedDecoratorImpl","constructor","decoratee","execute","model","ids","result","isFail","entries","value","nonDeletedEntries","filter","entry","wbyDeleted","ok","GetEntriesByIdsNotDeletedDecorator","abstraction","decorator","dependencies"],"sources":["GetEntriesByIdsNotDeletedDecorator.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/feature/api\";\nimport { GetEntriesByIdsUseCase } from \"../abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\n\n/**\n * GetEntriesByIdsNotDeletedDecorator - Filters out deleted entries.\n *\n * This decorator wraps the GetEntriesByIdsUseCase and filters out\n * entries marked as deleted (wbyDeleted flag).\n */\nclass GetEntriesByIdsNotDeletedDecoratorImpl implements GetEntriesByIdsUseCase.Interface {\n    public constructor(private decoratee: GetEntriesByIdsUseCase.Interface) {}\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], GetEntriesByIdsUseCase.Error>> {\n        const result = await this.decoratee.execute<T>(model, ids);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const entries = result.value;\n\n        // Filter out deleted entries\n        const nonDeletedEntries = entries.filter(entry => !entry.wbyDeleted);\n\n        return Result.ok(nonDeletedEntries);\n    }\n}\n\nexport const GetEntriesByIdsNotDeletedDecorator = createDecorator({\n    abstraction: GetEntriesByIdsUseCase,\n    decorator: GetEntriesByIdsNotDeletedDecoratorImpl,\n    dependencies: []\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,qBAAqB;AACrD,SAASC,sBAAsB;AAC/B,SAASC,MAAM,QAAQ,qBAAqB;AAG5C;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,sCAAsC,CAA6C;EAC9EC,WAAWA,CAASC,SAA2C,EAAE;IAAA,KAA7CA,SAA2C,GAA3CA,SAA2C;EAAG;EAEzE,MAAMC,OAAOA,CACTC,KAAe,EACfC,GAAa,EAC+C;IAC5D,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,SAAS,CAACC,OAAO,CAAIC,KAAK,EAAEC,GAAG,CAAC;IAE1D,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IAEA,MAAME,OAAO,GAAGF,MAAM,CAACG,KAAK;;IAE5B;IACA,MAAMC,iBAAiB,GAAGF,OAAO,CAACG,MAAM,CAACC,KAAK,IAAI,CAACA,KAAK,CAACC,UAAU,CAAC;IAEpE,OAAOd,MAAM,CAACe,EAAE,CAACJ,iBAAiB,CAAC;EACvC;AACJ;AAEA,OAAO,MAAMK,kCAAkC,GAAGlB,eAAe,CAAC;EAC9DmB,WAAW,EAAElB,sBAAsB;EACnCmB,SAAS,EAAEjB,sCAAsC;EACjDkB,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/GetEntriesByIds/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetEntriesByIdsUseCase } from "./GetEntriesByIdsUseCase.js";
+import { GetEntriesByIdsRepository } from "./GetEntriesByIdsRepository.js";
+import { GetEntriesByIdsNotDeletedDecorator } from "./decorators/GetEntriesByIdsNotDeletedDecorator.js";
+export const GetEntriesByIdsFeature = createFeature({
+  name: "GetEntriesByIds",
+  register(container) {
+    container.register(GetEntriesByIdsUseCase);
+    container.register(GetEntriesByIdsRepository).inSingletonScope();
+    container.registerDecorator(GetEntriesByIdsNotDeletedDecorator);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetEntriesByIdsUseCase","GetEntriesByIdsRepository","GetEntriesByIdsNotDeletedDecorator","GetEntriesByIdsFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetEntriesByIdsUseCase } from \"./GetEntriesByIdsUseCase.js\";\nimport { GetEntriesByIdsRepository } from \"./GetEntriesByIdsRepository.js\";\nimport { GetEntriesByIdsNotDeletedDecorator } from \"./decorators/GetEntriesByIdsNotDeletedDecorator.js\";\n\nexport const GetEntriesByIdsFeature = createFeature({\n    name: \"GetEntriesByIds\",\n    register(container) {\n        container.register(GetEntriesByIdsUseCase);\n        container.register(GetEntriesByIdsRepository).inSingletonScope();\n        container.registerDecorator(GetEntriesByIdsNotDeletedDecorator);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAClC,SAASC,kCAAkC;AAE3C,OAAO,MAAMC,sBAAsB,GAAGJ,aAAa,CAAC;EAChDK,IAAI,EAAE,iBAAiB;EACvBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,sBAAsB,CAAC;IAC1CM,SAAS,CAACD,QAAQ,CAACJ,yBAAyB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAChED,SAAS,CAACE,iBAAiB,CAACN,kCAAkC,CAAC;EACnE;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export { GetEntriesByIdsUseCase, GetEntriesByIdsRepository } from "./abstractions.js";

package/features/contentEntry/GetEntriesByIds/index.js

@@ -0,0 +1,3 @@
+export { GetEntriesByIdsUseCase, GetEntriesByIdsRepository } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetEntriesByIdsUseCase","GetEntriesByIdsRepository"],"sources":["index.ts"],"sourcesContent":["export { GetEntriesByIdsUseCase, GetEntriesByIdsRepository } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,sBAAsB,EAAEC,yBAAyB","ignoreList":[]}

package/features/contentEntry/GetEntry/GetEntryUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntryUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListEntriesUseCase } from "../ListEntries/abstractions.js";
+import type { CmsEntry, CmsEntryGetParams, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * GetEntryUseCase - Gets a single entry by query.
+ * Delegates to ListEntriesUseCase with limit 1 and returns first entry.
+ */
+declare class GetEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private listEntriesUseCase;
+    constructor(listEntriesUseCase: ListEntriesUseCase.Interface);
+    execute<T extends CmsEntryValues>(model: CmsModel, params: CmsEntryGetParams): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+}
+export declare const GetEntryUseCase: import("@webiny/di").Implementation<typeof GetEntryUseCaseImpl>;
+export {};