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

package/features/contentEntry/GetPreviousRevisionByEntryId/GetPreviousRevisionByEntryIdRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","GetPreviousRevisionByEntryIdRepository","RepositoryAbstraction","EntryNotFoundError","EntryPersistenceError","StorageOperations","EntryFromStorageTransform","GetPreviousRevisionByEntryIdRepositoryImpl","constructor","entryFromStorageTransform","storageOperations","execute","model","params","entry","entries","getPreviousRevision","fail","entryId","transformedEntry","ok","error","abstraction","implementation","dependencies"],"sources":["GetPreviousRevisionByEntryIdRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { GetPreviousRevisionByEntryIdRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { EntryNotFoundError, EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    CmsEntryStorageOperationsGetPreviousRevisionParams\n} from \"~/types/index.js\";\nimport { StorageOperations } from \"~/features/shared/abstractions.js\";\nimport { EntryFromStorageTransform } from \"~/legacy/abstractions.js\";\n\n/**\n * GetPreviousRevisionByEntryIdRepository - Fetches previous revision by entry ID and version from storage.\n * Returns the previous revision for a given entry (includes deleted entries).\n */\nclass GetPreviousRevisionByEntryIdRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private entryFromStorageTransform: EntryFromStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        params: CmsEntryStorageOperationsGetPreviousRevisionParams\n    ): Promise<Result<CmsEntry<T>, RepositoryAbstraction.Error>> {\n        try {\n            const entry = await this.storageOperations.entries.getPreviousRevision<T>(\n                model,\n                params\n            );\n\n            if (!entry) {\n                return Result.fail(new EntryNotFoundError(params.entryId));\n            }\n\n            // Transform storage entry to domain entry\n            const transformedEntry = await this.entryFromStorageTransform(model, entry);\n\n            return Result.ok(transformedEntry);\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const GetPreviousRevisionByEntryIdRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: GetPreviousRevisionByEntryIdRepositoryImpl,\n    dependencies: [EntryFromStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,sCAAsC,IAAIC,qBAAqB;AACxE,SAASC,kBAAkB,EAAEC,qBAAqB;AAOlD,SAASC,iBAAiB;AAC1B,SAASC,yBAAyB;;AAElC;AACA;AACA;AACA;AACA,MAAMC,0CAA0C,CAA4C;EACjFC,WAAWA,CACNC,yBAA8D,EAC9DC,iBAA8C,EACxD;IAAA,KAFUD,yBAA8D,GAA9DA,yBAA8D;IAAA,KAC9DC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAMC,OAAOA,CACTC,KAAe,EACfC,MAA0D,EACD;IACzD,IAAI;MACA,MAAMC,KAAK,GAAG,MAAM,IAAI,CAACJ,iBAAiB,CAACK,OAAO,CAACC,mBAAmB,CAClEJ,KAAK,EACLC,MACJ,CAAC;MAED,IAAI,CAACC,KAAK,EAAE;QACR,OAAOf,MAAM,CAACkB,IAAI,CAAC,IAAId,kBAAkB,CAACU,MAAM,CAACK,OAAO,CAAC,CAAC;MAC9D;;MAEA;MACA,MAAMC,gBAAgB,GAAG,MAAM,IAAI,CAACV,yBAAyB,CAACG,KAAK,EAAEE,KAAK,CAAC;MAE3E,OAAOf,MAAM,CAACqB,EAAE,CAACD,gBAAgB,CAAC;IACtC,CAAC,CAAC,OAAOE,KAAK,EAAE;MACZ,OAAOtB,MAAM,CAACkB,IAAI,CAAC,IAAIb,qBAAqB,CAACiB,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMpB,sCAAsC,GAAGD,oBAAoB,CAAC;EACvEsB,WAAW,EAAEpB,qBAAqB;EAClCqB,cAAc,EAAEhB,0CAA0C;EAC1DiB,YAAY,EAAE,CAAClB,yBAAyB,EAAED,iBAAiB;AAC/D,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetPreviousRevisionByEntryId/GetPreviousRevisionByEntryIdUseCase.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { GetPreviousRevisionByEntryIdUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetPreviousRevisionByEntryIdBaseUseCase } from "./abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel, CmsEntryStorageOperationsGetPreviousRevisionParams } from "../../../types/index.js";
+/**
+ * Returns non-deleted previous revision only.
+ *
+ * Composes the base use case and filters out deleted entries.
+ */
+declare class GetPreviousRevisionByEntryIdUseCaseImpl implements UseCaseAbstraction.Interface {
+    private baseUseCase;
+    constructor(baseUseCase: GetPreviousRevisionByEntryIdBaseUseCase.Interface);
+    execute<T extends CmsEntryValues>(model: CmsModel, params: CmsEntryStorageOperationsGetPreviousRevisionParams): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>>;
+}
+export declare const GetPreviousRevisionByEntryIdUseCase: import("@webiny/di").Implementation<typeof GetPreviousRevisionByEntryIdUseCaseImpl>;
+export {};

package/features/contentEntry/GetPreviousRevisionByEntryId/GetPreviousRevisionByEntryIdUseCase.js

@@ -0,0 +1,36 @@
+import { createImplementation, Result } from "@webiny/feature/api";
+import { GetPreviousRevisionByEntryIdUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetPreviousRevisionByEntryIdBaseUseCase } from "./abstractions.js";
+import { EntryNotFoundError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * Returns non-deleted previous revision only.
+ *
+ * Composes the base use case and filters out deleted entries.
+ */
+class GetPreviousRevisionByEntryIdUseCaseImpl {
+  constructor(baseUseCase) {
+    this.baseUseCase = baseUseCase;
+  }
+  async execute(model, params) {
+    const result = await this.baseUseCase.execute(model, params);
+    if (result.isFail()) {
+      return result;
+    }
+    const entry = result.value;
+
+    // Return error if entry is deleted
+    if (entry.wbyDeleted) {
+      // TODO: should we be loading revisions till we find one that is not deleted?
+      return Result.fail(new EntryNotFoundError(params.entryId));
+    }
+    return Result.ok(entry);
+  }
+}
+export const GetPreviousRevisionByEntryIdUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: GetPreviousRevisionByEntryIdUseCaseImpl,
+  dependencies: [GetPreviousRevisionByEntryIdBaseUseCase]
+});
+
+//# sourceMappingURL=GetPreviousRevisionByEntryIdUseCase.js.map

package/features/contentEntry/GetPreviousRevisionByEntryId/GetPreviousRevisionByEntryIdUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","GetPreviousRevisionByEntryIdUseCase","UseCaseAbstraction","GetPreviousRevisionByEntryIdBaseUseCase","EntryNotFoundError","GetPreviousRevisionByEntryIdUseCaseImpl","constructor","baseUseCase","execute","model","params","result","isFail","entry","value","wbyDeleted","fail","entryId","ok","abstraction","implementation","dependencies"],"sources":["GetPreviousRevisionByEntryIdUseCase.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport { GetPreviousRevisionByEntryIdUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetPreviousRevisionByEntryIdBaseUseCase } from \"./abstractions.js\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    CmsEntryStorageOperationsGetPreviousRevisionParams\n} from \"~/types/index.js\";\nimport { EntryNotFoundError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * Returns non-deleted previous revision only.\n *\n * Composes the base use case and filters out deleted entries.\n */\nclass GetPreviousRevisionByEntryIdUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private baseUseCase: GetPreviousRevisionByEntryIdBaseUseCase.Interface) {}\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        params: CmsEntryStorageOperationsGetPreviousRevisionParams\n    ): Promise<Result<CmsEntry<T>, UseCaseAbstraction.Error>> {\n        const result = await this.baseUseCase.execute<T>(model, params);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const entry = result.value;\n\n        // Return error if entry is deleted\n        if (entry.wbyDeleted) {\n            // TODO: should we be loading revisions till we find one that is not deleted?\n            return Result.fail(new EntryNotFoundError(params.entryId));\n        }\n\n        return Result.ok(entry);\n    }\n}\n\nexport const GetPreviousRevisionByEntryIdUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetPreviousRevisionByEntryIdUseCaseImpl,\n    dependencies: [GetPreviousRevisionByEntryIdBaseUseCase]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,EAAEC,MAAM,QAAQ,qBAAqB;AAClE,SAASC,mCAAmC,IAAIC,kBAAkB;AAClE,SAASC,uCAAuC;AAOhD,SAASC,kBAAkB;;AAE3B;AACA;AACA;AACA;AACA;AACA,MAAMC,uCAAuC,CAAyC;EAC3EC,WAAWA,CAASC,WAA8D,EAAE;IAAA,KAAhEA,WAA8D,GAA9DA,WAA8D;EAAG;EAE5F,MAAMC,OAAOA,CACTC,KAAe,EACfC,MAA0D,EACJ;IACtD,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,WAAW,CAACC,OAAO,CAAIC,KAAK,EAAEC,MAAM,CAAC;IAE/D,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IAEA,MAAME,KAAK,GAAGF,MAAM,CAACG,KAAK;;IAE1B;IACA,IAAID,KAAK,CAACE,UAAU,EAAE;MAClB;MACA,OAAOf,MAAM,CAACgB,IAAI,CAAC,IAAIZ,kBAAkB,CAACM,MAAM,CAACO,OAAO,CAAC,CAAC;IAC9D;IAEA,OAAOjB,MAAM,CAACkB,EAAE,CAACL,KAAK,CAAC;EAC3B;AACJ;AAEA,OAAO,MAAMZ,mCAAmC,GAAGF,oBAAoB,CAAC;EACpEoB,WAAW,EAAEjB,kBAAkB;EAC/BkB,cAAc,EAAEf,uCAAuC;EACvDgB,YAAY,EAAE,CAAClB,uCAAuC;AAC1D,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,51 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsEntry, CmsEntryStorageOperationsGetPreviousRevisionParams, CmsEntryValues, CmsModel } from "../../../types/index.js";
+import type { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+import { EntryNotFoundError, type EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+/**
+ * Base internal use case - returns entry regardless of deleted state.
+ * This is used internally by the public variation.
+ */
+export interface IGetPreviousRevisionByEntryIdBaseUseCase {
+    execute<T extends CmsEntryValues>(model: CmsModel, params: CmsEntryStorageOperationsGetPreviousRevisionParams): Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+export interface IGetPreviousRevisionByEntryIdUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    notFound: EntryNotFoundError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IGetPreviousRevisionByEntryIdUseCaseErrors[keyof IGetPreviousRevisionByEntryIdUseCaseErrors];
+export declare const GetPreviousRevisionByEntryIdBaseUseCase: import("@webiny/di").Abstraction<IGetPreviousRevisionByEntryIdBaseUseCase>;
+export declare namespace GetPreviousRevisionByEntryIdBaseUseCase {
+    type Interface = IGetPreviousRevisionByEntryIdBaseUseCase;
+    type Params = CmsEntryStorageOperationsGetPreviousRevisionParams;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+/**
+ * Public use case: Returns non-deleted revision only (default behavior)
+ */
+export declare const GetPreviousRevisionByEntryIdUseCase: import("@webiny/di").Abstraction<IGetPreviousRevisionByEntryIdBaseUseCase>;
+export declare namespace GetPreviousRevisionByEntryIdUseCase {
+    type Interface = IGetPreviousRevisionByEntryIdBaseUseCase;
+    type Params = CmsEntryStorageOperationsGetPreviousRevisionParams;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;
+}
+/**
+ * GetPreviousRevisionByEntryIdRepository - Fetches previous revision from storage by entry ID and version.
+ */
+export interface IGetPreviousRevisionByEntryIdRepository {
+    execute<T extends CmsEntryValues>(model: CmsModel, params: CmsEntryStorageOperationsGetPreviousRevisionParams): Promise<Result<CmsEntry<T>, RepositoryError>>;
+}
+export interface IGetPreviousRevisionByEntryIdRepositoryErrors {
+    storage: EntryPersistenceError;
+    notFound: EntryNotFoundError;
+}
+type RepositoryError = IGetPreviousRevisionByEntryIdRepositoryErrors[keyof IGetPreviousRevisionByEntryIdRepositoryErrors];
+export declare const GetPreviousRevisionByEntryIdRepository: import("@webiny/di").Abstraction<IGetPreviousRevisionByEntryIdRepository>;
+export declare namespace GetPreviousRevisionByEntryIdRepository {
+    type Interface = IGetPreviousRevisionByEntryIdRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/GetPreviousRevisionByEntryId/abstractions.js

@@ -0,0 +1,20 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * Base internal use case - returns entry regardless of deleted state.
+ * This is used internally by the public variation.
+ */
+
+export const GetPreviousRevisionByEntryIdBaseUseCase = createAbstraction("GetPreviousRevisionByEntryIdBaseUseCase");
+/**
+ * Public use case: Returns non-deleted revision only (default behavior)
+ */
+export const GetPreviousRevisionByEntryIdUseCase = createAbstraction("GetPreviousRevisionByEntryIdUseCase");
+
+/**
+ * GetPreviousRevisionByEntryIdRepository - Fetches previous revision from storage by entry ID and version.
+ */
+
+export const GetPreviousRevisionByEntryIdRepository = createAbstraction("GetPreviousRevisionByEntryIdRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetPreviousRevisionByEntryIdBaseUseCase","GetPreviousRevisionByEntryIdUseCase","GetPreviousRevisionByEntryIdRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryStorageOperationsGetPreviousRevisionParams,\n    CmsEntryValues,\n    CmsModel\n} from \"~/types/index.js\";\nimport type { EntryNotAuthorizedError } from \"~/domain/contentEntry/errors.js\";\nimport { EntryNotFoundError, type EntryPersistenceError } from \"~/domain/contentEntry/errors.js\";\n\n/**\n * Base internal use case - returns entry regardless of deleted state.\n * This is used internally by the public variation.\n */\nexport interface IGetPreviousRevisionByEntryIdBaseUseCase {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        params: CmsEntryStorageOperationsGetPreviousRevisionParams\n    ): Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\nexport interface IGetPreviousRevisionByEntryIdUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    notFound: EntryNotFoundError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError =\n    IGetPreviousRevisionByEntryIdUseCaseErrors[keyof IGetPreviousRevisionByEntryIdUseCaseErrors];\n\nexport const GetPreviousRevisionByEntryIdBaseUseCase =\n    createAbstraction<IGetPreviousRevisionByEntryIdBaseUseCase>(\n        \"GetPreviousRevisionByEntryIdBaseUseCase\"\n    );\n\nexport namespace GetPreviousRevisionByEntryIdBaseUseCase {\n    export type Interface = IGetPreviousRevisionByEntryIdBaseUseCase;\n    export type Params = CmsEntryStorageOperationsGetPreviousRevisionParams;\n\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\n/**\n * Public use case: Returns non-deleted revision only (default behavior)\n */\nexport const GetPreviousRevisionByEntryIdUseCase =\n    createAbstraction<IGetPreviousRevisionByEntryIdBaseUseCase>(\n        \"GetPreviousRevisionByEntryIdUseCase\"\n    );\n\nexport namespace GetPreviousRevisionByEntryIdUseCase {\n    export type Interface = IGetPreviousRevisionByEntryIdBaseUseCase;\n    export type Params = CmsEntryStorageOperationsGetPreviousRevisionParams;\n\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>, UseCaseError>>;\n}\n\n/**\n * GetPreviousRevisionByEntryIdRepository - Fetches previous revision from storage by entry ID and version.\n */\nexport interface IGetPreviousRevisionByEntryIdRepository {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        params: CmsEntryStorageOperationsGetPreviousRevisionParams\n    ): Promise<Result<CmsEntry<T>, RepositoryError>>;\n}\n\nexport interface IGetPreviousRevisionByEntryIdRepositoryErrors {\n    storage: EntryPersistenceError;\n    notFound: EntryNotFoundError;\n}\n\ntype RepositoryError =\n    IGetPreviousRevisionByEntryIdRepositoryErrors[keyof IGetPreviousRevisionByEntryIdRepositoryErrors];\n\nexport const GetPreviousRevisionByEntryIdRepository =\n    createAbstraction<IGetPreviousRevisionByEntryIdRepository>(\n        \"GetPreviousRevisionByEntryIdRepository\"\n    );\n\nexport namespace GetPreviousRevisionByEntryIdRepository {\n    export type Interface = IGetPreviousRevisionByEntryIdRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAU/D;AACA;AACA;AACA;;AAiBA,OAAO,MAAMC,uCAAuC,GAChDD,iBAAiB,CACb,yCACJ,CAAC;AAUL;AACA;AACA;AACA,OAAO,MAAME,mCAAmC,GAC5CF,iBAAiB,CACb,qCACJ,CAAC;;AAUL;AACA;AACA;;AAgBA,OAAO,MAAMG,sCAAsC,GAC/CH,iBAAiB,CACb,wCACJ,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/GetPreviousRevisionByEntryId/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/api";
+import { BaseUseCase } from "./BaseUseCase.js";
+import { GetPreviousRevisionByEntryIdRepository } from "./GetPreviousRevisionByEntryIdRepository.js";
+import { GetPreviousRevisionByEntryIdUseCase } from "./GetPreviousRevisionByEntryIdUseCase.js";
+export const GetPreviousRevisionByEntryIdFeature = createFeature({
+  name: "GetPreviousRevisionByEntryId",
+  register(container) {
+    // Register repository (singleton scope)
+    container.register(GetPreviousRevisionByEntryIdRepository).inSingletonScope();
+
+    // Register base use case (internal, returns any entry regardless of deleted state)
+    container.register(BaseUseCase);
+
+    // Register public use case (non-deleted entries only)
+    container.register(GetPreviousRevisionByEntryIdUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","BaseUseCase","GetPreviousRevisionByEntryIdRepository","GetPreviousRevisionByEntryIdUseCase","GetPreviousRevisionByEntryIdFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { BaseUseCase } from \"./BaseUseCase.js\";\nimport { GetPreviousRevisionByEntryIdRepository } from \"./GetPreviousRevisionByEntryIdRepository.js\";\nimport { GetPreviousRevisionByEntryIdUseCase } from \"./GetPreviousRevisionByEntryIdUseCase.js\";\n\nexport const GetPreviousRevisionByEntryIdFeature = createFeature({\n    name: \"GetPreviousRevisionByEntryId\",\n    register(container) {\n        // Register repository (singleton scope)\n        container.register(GetPreviousRevisionByEntryIdRepository).inSingletonScope();\n\n        // Register base use case (internal, returns any entry regardless of deleted state)\n        container.register(BaseUseCase);\n\n        // Register public use case (non-deleted entries only)\n        container.register(GetPreviousRevisionByEntryIdUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,WAAW;AACpB,SAASC,sCAAsC;AAC/C,SAASC,mCAAmC;AAE5C,OAAO,MAAMC,mCAAmC,GAAGJ,aAAa,CAAC;EAC7DK,IAAI,EAAE,8BAA8B;EACpCC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,sCAAsC,CAAC,CAACM,gBAAgB,CAAC,CAAC;;IAE7E;IACAD,SAAS,CAACD,QAAQ,CAACL,WAAW,CAAC;;IAE/B;IACAM,SAAS,CAACD,QAAQ,CAACH,mCAAmC,CAAC;EAC3D;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export { GetPreviousRevisionByEntryIdUseCase, GetPreviousRevisionByEntryIdRepository, GetPreviousRevisionByEntryIdBaseUseCase } from "./abstractions.js";

package/features/contentEntry/GetPreviousRevisionByEntryId/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetPreviousRevisionByEntryIdUseCase","GetPreviousRevisionByEntryIdRepository","GetPreviousRevisionByEntryIdBaseUseCase"],"sources":["index.ts"],"sourcesContent":["export {\n    GetPreviousRevisionByEntryIdUseCase,\n    GetPreviousRevisionByEntryIdRepository,\n    GetPreviousRevisionByEntryIdBaseUseCase\n} from \"./abstractions.js\";\n"],"mappings":"AAAA,SACIA,mCAAmC,EACnCC,sCAAsC,EACtCC,uCAAuC","ignoreList":[]}

package/features/contentEntry/GetPublishedEntriesByIds/GetPublishedEntriesByIdsRepository.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { GetPublishedEntriesByIdsRepository 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";
+/**
+ * GetPublishedEntriesByIdsRepository - Fetches published entries by entry IDs from storage.
+ * Returns array of published entries.
+ */
+declare class GetPublishedEntriesByIdsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private entryFromStorageTransform;
+    private storageOperations;
+    constructor(entryFromStorageTransform: EntryFromStorageTransform.Interface, storageOperations: StorageOperations.Interface);
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], RepositoryAbstraction.Error>>;
+}
+export declare const GetPublishedEntriesByIdsRepository: import("@webiny/di").Implementation<typeof GetPublishedEntriesByIdsRepositoryImpl>;
+export {};

package/features/contentEntry/GetPublishedEntriesByIds/GetPublishedEntriesByIdsRepository.js

@@ -0,0 +1,38 @@
+import { createImplementation, Result } from "@webiny/feature/api";
+import { GetPublishedEntriesByIdsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryFromStorageTransform } from "../../../legacy/abstractions.js";
+
+/**
+ * GetPublishedEntriesByIdsRepository - Fetches published entries by entry IDs from storage.
+ * Returns array of published entries.
+ */
+class GetPublishedEntriesByIdsRepositoryImpl {
+  constructor(entryFromStorageTransform, storageOperations) {
+    this.entryFromStorageTransform = entryFromStorageTransform;
+    this.storageOperations = storageOperations;
+  }
+  async execute(model, ids) {
+    try {
+      const result = await this.storageOperations.entries.getPublishedByIds(model, {
+        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 GetPublishedEntriesByIdsRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: GetPublishedEntriesByIdsRepositoryImpl,
+  dependencies: [EntryFromStorageTransform, StorageOperations]
+});
+
+//# sourceMappingURL=GetPublishedEntriesByIdsRepository.js.map

package/features/contentEntry/GetPublishedEntriesByIds/GetPublishedEntriesByIdsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","GetPublishedEntriesByIdsRepository","RepositoryAbstraction","EntryPersistenceError","StorageOperations","EntryFromStorageTransform","GetPublishedEntriesByIdsRepositoryImpl","constructor","entryFromStorageTransform","storageOperations","execute","model","ids","result","entries","getPublishedByIds","items","Promise","all","map","entry","ok","error","fail","abstraction","implementation","dependencies"],"sources":["GetPublishedEntriesByIdsRepository.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport { GetPublishedEntriesByIdsRepository 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\";\n\n/**\n * GetPublishedEntriesByIdsRepository - Fetches published entries by entry IDs from storage.\n * Returns array of published entries.\n */\nclass GetPublishedEntriesByIdsRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private entryFromStorageTransform: EntryFromStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], RepositoryAbstraction.Error>> {\n        try {\n            const result = await this.storageOperations.entries.getPublishedByIds<T>(model, {\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 GetPublishedEntriesByIdsRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: GetPublishedEntriesByIdsRepositoryImpl,\n    dependencies: [EntryFromStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,EAAEC,MAAM,QAAQ,qBAAqB;AAClE,SAASC,kCAAkC,IAAIC,qBAAqB;AACpE,SAASC,qBAAqB;AAE9B,SAASC,iBAAiB;AAC1B,SAASC,yBAAyB;;AAElC;AACA;AACA;AACA;AACA,MAAMC,sCAAsC,CAA4C;EAC7EC,WAAWA,CACNC,yBAA8D,EAC9DC,iBAA8C,EACxD;IAAA,KAFUD,yBAA8D,GAA9DA,yBAA8D;IAAA,KAC9DC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAaC,OAAOA,CAChBC,KAAe,EACfC,GAAa,EAC8C;IAC3D,IAAI;MACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,iBAAiB,CAACK,OAAO,CAACC,iBAAiB,CAAIJ,KAAK,EAAE;QAC5EC;MACJ,CAAC,CAAC;;MAEF;MACA,MAAMI,KAAK,GAAG,MAAMC,OAAO,CAACC,GAAG,CAC3BL,MAAM,CAACM,GAAG,CAAC,MAAMC,KAAK,IAAI;QACtB,OAAO,IAAI,CAACZ,yBAAyB,CAACG,KAAK,EAAES,KAAK,CAAC;MACvD,CAAC,CACL,CAAC;MAED,OAAOpB,MAAM,CAACqB,EAAE,CAACL,KAAK,CAAC;IAC3B,CAAC,CAAC,OAAOM,KAAK,EAAE;MACZ,OAAOtB,MAAM,CAACuB,IAAI,CAAC,IAAIpB,qBAAqB,CAACmB,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMrB,kCAAkC,GAAGF,oBAAoB,CAAC;EACnEyB,WAAW,EAAEtB,qBAAqB;EAClCuB,cAAc,EAAEnB,sCAAsC;EACtDoB,YAAY,EAAE,CAACrB,yBAAyB,EAAED,iBAAiB;AAC/D,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetPublishedEntriesByIds/GetPublishedEntriesByIdsUseCase.d.ts

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

package/features/contentEntry/GetPublishedEntriesByIds/GetPublishedEntriesByIdsUseCase.js

@@ -0,0 +1,43 @@
+import { Result } from "@webiny/feature/api";
+import { createImplementation } from "@webiny/feature/api";
+import { GetPublishedEntriesByIdsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetPublishedEntriesByIdsRepository } from "./abstractions.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { EntryNotAuthorizedError } from "../../../domain/contentEntry/errors.js";
+
+/**
+ * GetPublishedEntriesByIdsUseCase - Orchestrates fetching published entries by IDs.
+ *
+ * Responsibilities:
+ * - Apply access control
+ * - Delegate to repository for data fetching
+ */
+class GetPublishedEntriesByIdsUseCaseImpl {
+  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 GetPublishedEntriesByIdsUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: GetPublishedEntriesByIdsUseCaseImpl,
+  dependencies: [GetPublishedEntriesByIdsRepository, AccessControl]
+});
+
+//# sourceMappingURL=GetPublishedEntriesByIdsUseCase.js.map

package/features/contentEntry/GetPublishedEntriesByIds/GetPublishedEntriesByIdsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","GetPublishedEntriesByIdsUseCase","UseCaseAbstraction","GetPublishedEntriesByIdsRepository","AccessControl","EntryNotAuthorizedError","GetPublishedEntriesByIdsUseCaseImpl","constructor","repository","accessControl","execute","model","ids","canAccess","canAccessEntry","fail","fromModel","result","isFail","error","ok","value","abstraction","implementation","dependencies"],"sources":["GetPublishedEntriesByIdsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { GetPublishedEntriesByIdsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetPublishedEntriesByIdsRepository } 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 * GetPublishedEntriesByIdsUseCase - Orchestrates fetching published entries by IDs.\n *\n * Responsibilities:\n * - Apply access control\n * - Delegate to repository for data fetching\n */\nclass GetPublishedEntriesByIdsUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private repository: GetPublishedEntriesByIdsRepository.Interface,\n        private accessControl: AccessControl.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = 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 GetPublishedEntriesByIdsUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetPublishedEntriesByIdsUseCaseImpl,\n    dependencies: [GetPublishedEntriesByIdsRepository, AccessControl]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,+BAA+B,IAAIC,kBAAkB;AAC9D,SAASC,kCAAkC;AAC3C,SAASC,aAAa;AAEtB,SAASC,uBAAuB;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mCAAmC,CAAyC;EACvEC,WAAWA,CACNC,UAAwD,EACxDC,aAAsC,EAChD;IAAA,KAFUD,UAAwD,GAAxDA,UAAwD;IAAA,KACxDC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAaC,OAAOA,CAChBC,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,+BAA+B,GAAGD,oBAAoB,CAAC;EAChEsB,WAAW,EAAEpB,kBAAkB;EAC/BqB,cAAc,EAAEjB,mCAAmC;EACnDkB,YAAY,EAAE,CAACrB,kCAAkC,EAAEC,aAAa;AACpE,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetPublishedEntriesByIds/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";
+/**
+ * GetPublishedEntriesByIds Use Case - Fetches published revisions by entry IDs.
+ * Returns array of published entries (excludes deleted entries via decorator).
+ */
+export interface IGetPublishedEntriesByIdsUseCase {
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], UseCaseError>>;
+}
+export interface IGetPublishedEntriesByIdsUseCaseErrors {
+    notAuthorized: EntryNotAuthorizedError;
+    storage: EntryPersistenceError;
+}
+type UseCaseError = IGetPublishedEntriesByIdsUseCaseErrors[keyof IGetPublishedEntriesByIdsUseCaseErrors];
+export declare const GetPublishedEntriesByIdsUseCase: import("@webiny/di").Abstraction<IGetPublishedEntriesByIdsUseCase>;
+export declare namespace GetPublishedEntriesByIdsUseCase {
+    type Interface = IGetPublishedEntriesByIdsUseCase;
+    type Error = UseCaseError;
+    type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>[], UseCaseError>>;
+}
+/**
+ * GetPublishedEntriesByIdsRepository - Fetches published entries from storage by entry IDs.
+ */
+export interface IGetPublishedEntriesByIdsRepository {
+    execute<T extends CmsEntryValues>(model: CmsModel, ids: string[]): Promise<Result<CmsEntry<T>[], RepositoryError>>;
+}
+export interface IGetPublishedEntriesByIdsRepositoryErrors {
+    storage: EntryPersistenceError;
+}
+type RepositoryError = IGetPublishedEntriesByIdsRepositoryErrors[keyof IGetPublishedEntriesByIdsRepositoryErrors];
+export declare const GetPublishedEntriesByIdsRepository: import("@webiny/di").Abstraction<IGetPublishedEntriesByIdsRepository>;
+export declare namespace GetPublishedEntriesByIdsRepository {
+    type Interface = IGetPublishedEntriesByIdsRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentEntry/GetPublishedEntriesByIds/abstractions.js

@@ -0,0 +1,16 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetPublishedEntriesByIds Use Case - Fetches published revisions by entry IDs.
+ * Returns array of published entries (excludes deleted entries via decorator).
+ */
+
+export const GetPublishedEntriesByIdsUseCase = createAbstraction("GetPublishedEntriesByIdsUseCase");
+
+/**
+ * GetPublishedEntriesByIdsRepository - Fetches published entries from storage by entry IDs.
+ */
+
+export const GetPublishedEntriesByIdsRepository = createAbstraction("GetPublishedEntriesByIdsRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetPublishedEntriesByIdsUseCase","GetPublishedEntriesByIdsRepository"],"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 * GetPublishedEntriesByIds Use Case - Fetches published revisions by entry IDs.\n * Returns array of published entries (excludes deleted entries via decorator).\n */\nexport interface IGetPublishedEntriesByIdsUseCase {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], UseCaseError>>;\n}\n\nexport interface IGetPublishedEntriesByIdsUseCaseErrors {\n    notAuthorized: EntryNotAuthorizedError;\n    storage: EntryPersistenceError;\n}\n\ntype UseCaseError =\n    IGetPublishedEntriesByIdsUseCaseErrors[keyof IGetPublishedEntriesByIdsUseCaseErrors];\n\nexport const GetPublishedEntriesByIdsUseCase = createAbstraction<IGetPublishedEntriesByIdsUseCase>(\n    \"GetPublishedEntriesByIdsUseCase\"\n);\n\nexport namespace GetPublishedEntriesByIdsUseCase {\n    export type Interface = IGetPublishedEntriesByIdsUseCase;\n    export type Error = UseCaseError;\n    export type Return<T extends CmsEntryValues> = Promise<Result<CmsEntry<T>[], UseCaseError>>;\n}\n\n/**\n * GetPublishedEntriesByIdsRepository - Fetches published entries from storage by entry IDs.\n */\nexport interface IGetPublishedEntriesByIdsRepository {\n    execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], RepositoryError>>;\n}\n\nexport interface IGetPublishedEntriesByIdsRepositoryErrors {\n    storage: EntryPersistenceError;\n}\n\ntype RepositoryError =\n    IGetPublishedEntriesByIdsRepositoryErrors[keyof IGetPublishedEntriesByIdsRepositoryErrors];\n\nexport const GetPublishedEntriesByIdsRepository =\n    createAbstraction<IGetPublishedEntriesByIdsRepository>(\"GetPublishedEntriesByIdsRepository\");\n\nexport namespace GetPublishedEntriesByIdsRepository {\n    export type Interface = IGetPublishedEntriesByIdsRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAO/D;AACA;AACA;AACA;;AAgBA,OAAO,MAAMC,+BAA+B,GAAGD,iBAAiB,CAC5D,iCACJ,CAAC;;AAQD;AACA;AACA;;AAeA,OAAO,MAAME,kCAAkC,GAC3CF,iBAAiB,CAAsC,oCAAoC,CAAC","ignoreList":[]}

package/features/contentEntry/GetPublishedEntriesByIds/decorators/GetPublishedEntriesByIdsNotDeletedDecorator.d.ts

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

package/features/contentEntry/GetPublishedEntriesByIds/decorators/GetPublishedEntriesByIdsNotDeletedDecorator.js

@@ -0,0 +1,32 @@
+import { createDecorator } from "@webiny/feature/api";
+import { GetPublishedEntriesByIdsUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+/**
+ * GetPublishedEntriesByIdsNotDeletedDecorator - Filters out deleted entries.
+ *
+ * This decorator wraps the GetPublishedEntriesByIdsUseCase and filters out
+ * entries marked as deleted (wbyDeleted flag).
+ */
+class GetPublishedEntriesByIdsNotDeletedDecoratorImpl {
+  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 GetPublishedEntriesByIdsNotDeletedDecorator = createDecorator({
+  abstraction: GetPublishedEntriesByIdsUseCase,
+  decorator: GetPublishedEntriesByIdsNotDeletedDecoratorImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=GetPublishedEntriesByIdsNotDeletedDecorator.js.map

package/features/contentEntry/GetPublishedEntriesByIds/decorators/GetPublishedEntriesByIdsNotDeletedDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createDecorator","GetPublishedEntriesByIdsUseCase","Result","GetPublishedEntriesByIdsNotDeletedDecoratorImpl","constructor","decoratee","execute","model","ids","result","isFail","entries","value","nonDeletedEntries","filter","entry","wbyDeleted","ok","GetPublishedEntriesByIdsNotDeletedDecorator","abstraction","decorator","dependencies"],"sources":["GetPublishedEntriesByIdsNotDeletedDecorator.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/feature/api\";\nimport { GetPublishedEntriesByIdsUseCase } from \"../abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\n\n/**\n * GetPublishedEntriesByIdsNotDeletedDecorator - Filters out deleted entries.\n *\n * This decorator wraps the GetPublishedEntriesByIdsUseCase and filters out\n * entries marked as deleted (wbyDeleted flag).\n */\nclass GetPublishedEntriesByIdsNotDeletedDecoratorImpl\n    implements GetPublishedEntriesByIdsUseCase.Interface\n{\n    public constructor(private decoratee: GetPublishedEntriesByIdsUseCase.Interface) {}\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        ids: string[]\n    ): Promise<Result<CmsEntry<T>[], GetPublishedEntriesByIdsUseCase.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 GetPublishedEntriesByIdsNotDeletedDecorator = createDecorator({\n    abstraction: GetPublishedEntriesByIdsUseCase,\n    decorator: GetPublishedEntriesByIdsNotDeletedDecoratorImpl,\n    dependencies: []\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,qBAAqB;AACrD,SAASC,+BAA+B;AACxC,SAASC,MAAM,QAAQ,qBAAqB;AAG5C;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,+CAA+C,CAErD;EACWC,WAAWA,CAASC,SAAoD,EAAE;IAAA,KAAtDA,SAAoD,GAApDA,SAAoD;EAAG;EAElF,MAAMC,OAAOA,CACTC,KAAe,EACfC,GAAa,EACwD;IACrE,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,2CAA2C,GAAGlB,eAAe,CAAC;EACvEmB,WAAW,EAAElB,+BAA+B;EAC5CmB,SAAS,EAAEjB,+CAA+C;EAC1DkB,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/GetPublishedEntriesByIds/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetPublishedEntriesByIdsUseCase } from "./GetPublishedEntriesByIdsUseCase.js";
+import { GetPublishedEntriesByIdsRepository } from "./GetPublishedEntriesByIdsRepository.js";
+import { GetPublishedEntriesByIdsNotDeletedDecorator } from "./decorators/GetPublishedEntriesByIdsNotDeletedDecorator.js";
+export const GetPublishedEntriesByIdsFeature = createFeature({
+  name: "GetPublishedEntriesByIds",
+  register(container) {
+    container.register(GetPublishedEntriesByIdsUseCase);
+    container.register(GetPublishedEntriesByIdsRepository).inSingletonScope();
+    container.registerDecorator(GetPublishedEntriesByIdsNotDeletedDecorator);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetPublishedEntriesByIdsUseCase","GetPublishedEntriesByIdsRepository","GetPublishedEntriesByIdsNotDeletedDecorator","GetPublishedEntriesByIdsFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetPublishedEntriesByIdsUseCase } from \"./GetPublishedEntriesByIdsUseCase.js\";\nimport { GetPublishedEntriesByIdsRepository } from \"./GetPublishedEntriesByIdsRepository.js\";\nimport { GetPublishedEntriesByIdsNotDeletedDecorator } from \"./decorators/GetPublishedEntriesByIdsNotDeletedDecorator.js\";\n\nexport const GetPublishedEntriesByIdsFeature = createFeature({\n    name: \"GetPublishedEntriesByIds\",\n    register(container) {\n        container.register(GetPublishedEntriesByIdsUseCase);\n        container.register(GetPublishedEntriesByIdsRepository).inSingletonScope();\n        container.registerDecorator(GetPublishedEntriesByIdsNotDeletedDecorator);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,+BAA+B;AACxC,SAASC,kCAAkC;AAC3C,SAASC,2CAA2C;AAEpD,OAAO,MAAMC,+BAA+B,GAAGJ,aAAa,CAAC;EACzDK,IAAI,EAAE,0BAA0B;EAChCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,+BAA+B,CAAC;IACnDM,SAAS,CAACD,QAAQ,CAACJ,kCAAkC,CAAC,CAACM,gBAAgB,CAAC,CAAC;IACzED,SAAS,CAACE,iBAAiB,CAACN,2CAA2C,CAAC;EAC5E;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/contentEntry/GetPublishedEntriesByIds/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetPublishedEntriesByIdsUseCase","GetPublishedEntriesByIdsRepository"],"sources":["index.ts"],"sourcesContent":["export {\n    GetPublishedEntriesByIdsUseCase,\n    GetPublishedEntriesByIdsRepository\n} from \"./abstractions.js\";\n"],"mappings":"AAAA,SACIA,+BAA+B,EAC/BC,kCAAkC","ignoreList":[]}

package/features/contentEntry/GetPublishedRevisionByEntryId/GetPublishedRevisionByEntryIdRepository.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { GetPublishedRevisionByEntryIdRepository 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";
+/**
+ * GetPublishedRevisionByEntryIdRepository - Fetches published revision from storage.
+ * Returns null if entry not found or is deleted.
+ */
+declare class GetPublishedRevisionByEntryIdRepositoryImpl implements RepositoryAbstraction.Interface {
+    private entryFromStorageTransform;
+    private storageOperations;
+    constructor(entryFromStorageTransform: EntryFromStorageTransform.Interface, storageOperations: StorageOperations.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, entryId: string): Promise<Result<CmsEntry<T>, RepositoryAbstraction.Error>>;
+}
+export declare const GetPublishedRevisionByEntryIdRepository: import("@webiny/di").Implementation<typeof GetPublishedRevisionByEntryIdRepositoryImpl>;
+export {};

package/features/contentEntry/GetPublishedRevisionByEntryId/GetPublishedRevisionByEntryIdRepository.js

@@ -0,0 +1,40 @@
+import { createImplementation, Result } from "@webiny/feature/api";
+import { GetPublishedRevisionByEntryIdRepository as RepositoryAbstraction } from "./abstractions.js";
+import { EntryNotFoundError, EntryPersistenceError } from "../../../domain/contentEntry/errors.js";
+import { StorageOperations } from "../../shared/abstractions.js";
+import { EntryFromStorageTransform } from "../../../legacy/abstractions.js";
+
+/**
+ * GetPublishedRevisionByEntryIdRepository - Fetches published revision from storage.
+ * Returns null if entry not found or is deleted.
+ */
+class GetPublishedRevisionByEntryIdRepositoryImpl {
+  constructor(entryFromStorageTransform, storageOperations) {
+    this.entryFromStorageTransform = entryFromStorageTransform;
+    this.storageOperations = storageOperations;
+  }
+  async execute(model, entryId) {
+    try {
+      // Get published revision from storage
+      const storageEntry = await this.storageOperations.entries.getPublishedRevisionByEntryId(model, {
+        id: entryId
+      });
+      if (!storageEntry || storageEntry.wbyDeleted) {
+        return Result.fail(new EntryNotFoundError(entryId));
+      }
+
+      // Transform storage entry to domain entry
+      const entry = await this.entryFromStorageTransform(model, storageEntry);
+      return Result.ok(entry);
+    } catch (error) {
+      return Result.fail(new EntryPersistenceError(error));
+    }
+  }
+}
+export const GetPublishedRevisionByEntryIdRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: GetPublishedRevisionByEntryIdRepositoryImpl,
+  dependencies: [EntryFromStorageTransform, StorageOperations]
+});
+
+//# sourceMappingURL=GetPublishedRevisionByEntryIdRepository.js.map

package/features/contentEntry/GetPublishedRevisionByEntryId/GetPublishedRevisionByEntryIdRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","GetPublishedRevisionByEntryIdRepository","RepositoryAbstraction","EntryNotFoundError","EntryPersistenceError","StorageOperations","EntryFromStorageTransform","GetPublishedRevisionByEntryIdRepositoryImpl","constructor","entryFromStorageTransform","storageOperations","execute","model","entryId","storageEntry","entries","getPublishedRevisionByEntryId","id","wbyDeleted","fail","entry","ok","error","abstraction","implementation","dependencies"],"sources":["GetPublishedRevisionByEntryIdRepository.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport { GetPublishedRevisionByEntryIdRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { EntryNotFoundError, 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\";\n\n/**\n * GetPublishedRevisionByEntryIdRepository - Fetches published revision from storage.\n * Returns null if entry not found or is deleted.\n */\nclass GetPublishedRevisionByEntryIdRepositoryImpl implements RepositoryAbstraction.Interface {\n    public constructor(\n        private entryFromStorageTransform: EntryFromStorageTransform.Interface,\n        private storageOperations: StorageOperations.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        entryId: string\n    ): Promise<Result<CmsEntry<T>, RepositoryAbstraction.Error>> {\n        try {\n            // Get published revision from storage\n            const storageEntry =\n                await this.storageOperations.entries.getPublishedRevisionByEntryId<T>(model, {\n                    id: entryId\n                });\n\n            if (!storageEntry || storageEntry.wbyDeleted) {\n                return Result.fail(new EntryNotFoundError(entryId));\n            }\n\n            // Transform storage entry to domain entry\n            const entry = await this.entryFromStorageTransform(model, storageEntry);\n\n            return Result.ok(entry);\n        } catch (error) {\n            return Result.fail(new EntryPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const GetPublishedRevisionByEntryIdRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: GetPublishedRevisionByEntryIdRepositoryImpl,\n    dependencies: [EntryFromStorageTransform, StorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,EAAEC,MAAM,QAAQ,qBAAqB;AAClE,SAASC,uCAAuC,IAAIC,qBAAqB;AACzE,SAASC,kBAAkB,EAAEC,qBAAqB;AAElD,SAASC,iBAAiB;AAC1B,SAASC,yBAAyB;;AAElC;AACA;AACA;AACA;AACA,MAAMC,2CAA2C,CAA4C;EAClFC,WAAWA,CACNC,yBAA8D,EAC9DC,iBAA8C,EACxD;IAAA,KAFUD,yBAA8D,GAA9DA,yBAA8D;IAAA,KAC9DC,iBAA8C,GAA9CA,iBAA8C;EACvD;EAEH,MAAaC,OAAOA,CAChBC,KAAe,EACfC,OAAe,EAC0C;IACzD,IAAI;MACA;MACA,MAAMC,YAAY,GACd,MAAM,IAAI,CAACJ,iBAAiB,CAACK,OAAO,CAACC,6BAA6B,CAAIJ,KAAK,EAAE;QACzEK,EAAE,EAAEJ;MACR,CAAC,CAAC;MAEN,IAAI,CAACC,YAAY,IAAIA,YAAY,CAACI,UAAU,EAAE;QAC1C,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAIhB,kBAAkB,CAACU,OAAO,CAAC,CAAC;MACvD;;MAEA;MACA,MAAMO,KAAK,GAAG,MAAM,IAAI,CAACX,yBAAyB,CAACG,KAAK,EAAEE,YAAY,CAAC;MAEvE,OAAOd,MAAM,CAACqB,EAAE,CAACD,KAAK,CAAC;IAC3B,CAAC,CAAC,OAAOE,KAAK,EAAE;MACZ,OAAOtB,MAAM,CAACmB,IAAI,CAAC,IAAIf,qBAAqB,CAACkB,KAAc,CAAC,CAAC;IACjE;EACJ;AACJ;AAEA,OAAO,MAAMrB,uCAAuC,GAAGF,oBAAoB,CAAC;EACxEwB,WAAW,EAAErB,qBAAqB;EAClCsB,cAAc,EAAEjB,2CAA2C;EAC3DkB,YAAY,EAAE,CAACnB,yBAAyB,EAAED,iBAAiB;AAC/D,CAAC,CAAC","ignoreList":[]}

package/features/contentEntry/GetPublishedRevisionByEntryId/GetPublishedRevisionByEntryIdUseCase.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { GetPublishedRevisionByEntryIdRepository, GetPublishedRevisionByEntryIdUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../types/index.js";
+/**
+ * GetPublishedRevisionByEntryIdUseCase - Orchestrates fetching published revision by entry ID.
+ *
+ * Responsibilities:
+ * - Delegate to repository for data fetching
+ * - Return null if entry not found or deleted
+ */
+declare class GetPublishedRevisionByEntryIdUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetPublishedRevisionByEntryIdRepository.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, entryId: string): Promise<Result<CmsEntry<T> | null, UseCaseAbstraction.Error>>;
+}
+export declare const GetPublishedRevisionByEntryIdUseCase: import("@webiny/di").Implementation<typeof GetPublishedRevisionByEntryIdUseCaseImpl>;
+export {};