@webiny/api-headless-cms 6.3.0 → 6.4.0-beta.0

package/crud/contentEntry.crud.js

@@ -1,4 +1,4 @@
-import WebinyError from "@webiny/error";
+import _webiny_error from "@webiny/error";
 import { CreateEntryUseCase } from "../features/contentEntry/CreateEntry/index.js";
 import { CreateEntryRevisionFromUseCase } from "../features/contentEntry/CreateEntryRevisionFrom/abstractions.js";
 import { UpdateEntryUseCase } from "../features/contentEntry/UpdateEntry/index.js";
@@ -20,376 +20,315 @@ import { DeleteMultipleEntriesUseCase } from "../features/contentEntry/DeleteMul
 import { RestoreEntryFromBinUseCase } from "../features/contentEntry/RestoreEntryFromBin/abstractions.js";
 import { UnpublishEntryUseCase } from "../features/contentEntry/UnpublishEntry/index.js";
 import { GetUniqueFieldValuesUseCase } from "../features/contentEntry/GetUniqueFieldValues/index.js";
-export const createContentEntryCrud = params => {
-  const {
-    context
-  } = params;
-  const createEntry = async (model, rawInput, options) => {
-    // Delegate to new CreateEntry use case
-    const useCase = context.container.resolve(CreateEntryUseCase);
-    const result = await useCase.execute(model, rawInput, options);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not create content entry.", error.code || "CREATE_ENTRY_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const createEntryRevisionFrom = async (model, sourceId, rawInput, options) => {
-    // Delegate to new CreateEntryRevisionFrom use case
-    const useCase = context.container.resolve(CreateEntryRevisionFromUseCase);
-    const result = await useCase.execute(model, sourceId, rawInput, options);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not create entry from existing one.", error.code || "CREATE_FROM_REVISION_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const updateEntry = async (model, id, rawInput, metaInput, options) => {
-    // Delegate to new UpdateEntry use case
-    const useCase = context.container.resolve(UpdateEntryUseCase);
-    const result = await useCase.execute(model, id, rawInput, metaInput, options);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not update existing entry.", error.code || "UPDATE_ERROR");
-    }
-    return result.value;
-  };
-  const validateEntry = async (model, id, input) => {
-    // Delegate to new ValidateEntry use case
-    const useCase = context.container.resolve(ValidateEntryUseCase);
-    const result = await useCase.execute(model, id || null, input);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not validate entry.", error.code || "VALIDATION_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const moveEntry = async (model, id, folderId) => {
-    // Delegate to new MoveEntry use case
-    const useCase = context.container.resolve(MoveEntryUseCase);
-    const result = await useCase.execute(model, id, folderId);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || `Could not move entry "${id}" of model "${model.modelId}".`, error.code || "MOVE_ENTRY_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const republishEntry = async (model, id) => {
-    // Delegate to new RepublishEntry use case
-    const useCase = context.container.resolve(RepublishEntryUseCase);
-    const result = await useCase.execute(model, id);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not republish entry.", error.code || "REPUBLISH_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const deleteEntryRevision = async (model, revisionId) => {
-    const useCase = context.container.resolve(DeleteEntryRevisionUseCase);
-    const result = await useCase.execute(model, revisionId);
-    if (result.isFail()) {
-      throw new WebinyError(result.error.message, result.error.code, result.error.data);
-    }
-  };
-  const deleteMultipleEntries = async (model, params) => {
-    // Delegate to new DeleteMultipleEntries use case
-    const useCase = context.container.resolve(DeleteMultipleEntriesUseCase);
-    const result = await useCase.execute(model, params);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not delete multiple entries.", error.code || "DELETE_ENTRIES_MULTIPLE_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const publishEntry = async (model, id) => {
-    // Delegate to new PublishEntry use case
-    const useCase = context.container.resolve(PublishEntryUseCase);
-    const result = await useCase.execute(model, id);
-    if (result.isFail()) {
-      // Convert Result error to WebinyError for backward compatibility
-      throw new WebinyError(result.error.message || "Could not publish entry.", result.error.code || "PUBLISH_ERROR", result.error.data);
-    }
-    return result.value;
-  };
-  const unpublishEntry = async (model, id) => {
-    // Delegate to new UnpublishEntry use case
-    const useCase = context.container.resolve(UnpublishEntryUseCase);
-    const result = await useCase.execute(model, id);
-    if (result.isFail()) {
-      const error = result.error;
-      throw new WebinyError(error.message || "Could not unpublish entry.", error.code || "UNPUBLISH_ERROR", error.data);
-    }
-    return result.value;
-  };
-  const getUniqueFieldValues = async (model, params) => {
-    const useCase = context.container.resolve(GetUniqueFieldValuesUseCase);
-    const result = await useCase.execute(model, params);
-    if (result.isFail()) {
-      throw new WebinyError(result.error.message, result.error.code, result.error.data);
-    }
-    return result.value;
-  };
-  return {
-    /**
-     * Get entries by exact revision IDs from the database.
-     */
-    async getEntriesByIds(model, ids) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async () => {
-        const useCase = context.container.resolve(GetEntriesByIdsUseCase);
-        const result = await useCase.execute(model, ids);
+import { UpdateRevisionDescriptionUseCase } from "../features/contentEntry/UpdateRevisionDescription/index.js";
+const createContentEntryCrud = (params)=>{
+    const { context } = params;
+    const createEntry = async (model, rawInput, options)=>{
+        const useCase = context.container.resolve(CreateEntryUseCase);
+        const result = await useCase.execute(model, rawInput, options);
         if (result.isFail()) {
-          const error = result.error;
-          throw new WebinyError(error.message || "Could not get entries by IDs.", error.code || "GET_ENTRIES_BY_IDS_ERROR", {
-            error,
-            ids,
-            model
-          });
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not create content entry.", error.code || "CREATE_ENTRY_ERROR", error.data);
         }
         return result.value;
-      });
-    },
-    /**
-     * Get a single entry by revision ID from the database.
-     */
-    async getEntryById(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntryById", async () => {
-        const useCase = context.container.resolve(GetEntryByIdUseCase);
-        const result = await useCase.execute(model, id);
+    };
+    const createEntryRevisionFrom = async (model, sourceId, rawInput, options)=>{
+        const useCase = context.container.resolve(CreateEntryRevisionFromUseCase);
+        const result = await useCase.execute(model, sourceId, rawInput, options);
         if (result.isFail()) {
-          const error = result.error;
-          throw new WebinyError(error.message || `Entry by ID "${id}" not found.`, error.code || "GET_ENTRY_BY_ID_ERROR", error.data);
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not create entry from existing one.", error.code || "CREATE_FROM_REVISION_ERROR", error.data);
         }
         return result.value;
-      });
-    },
-    /**
-     * Get published revisions by entry IDs.
-     */
-    async getPublishedEntriesByIds(model, ids) {
-      return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async () => {
-        const useCase = context.container.resolve(GetPublishedEntriesByIdsUseCase);
-        const result = await useCase.execute(model, ids);
+    };
+    const updateEntry = async (model, id, rawInput, options)=>{
+        const useCase = context.container.resolve(UpdateEntryUseCase);
+        const result = await useCase.execute(model, id, rawInput, options);
         if (result.isFail()) {
-          const error = result.error;
-          throw new WebinyError(error.message || "Could not get published entries by IDs.", error.code || "GET_PUBLISHED_ENTRIES_BY_IDS_ERROR", {
-            error,
-            ids,
-            model
-          });
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not update existing entry.", error.code || "UPDATE_ERROR");
         }
         return result.value;
-      });
-    },
-    /**
-     * Get the latest revisions by entry IDs.
-     */
-    async getLatestEntriesByIds(model, ids) {
-      return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async () => {
-        const useCase = context.container.resolve(GetLatestEntriesByIdsUseCase);
-        const result = await useCase.execute(model, ids);
+    };
+    const updateRevisionDescription = async (model, id, revisionDescription)=>{
+        const useCase = context.container.resolve(UpdateRevisionDescriptionUseCase);
+        const result = await useCase.execute(model, id, revisionDescription);
         if (result.isFail()) {
-          const error = result.error;
-          throw new WebinyError(error.message || "Could not get latest entries by IDs.", error.code || "GET_LATEST_ENTRIES_BY_IDS_ERROR", {
-            error,
-            ids,
-            model
-          });
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not update revision description of the revision.", error.code || "UPDATE_REVISION_DESCRIPTION_ERROR");
         }
         return result.value;
-      });
-    },
-    async getEntryRevisions(model, entryId) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntryRevisions", async () => {
-        const useCase = context.container.resolve(GetRevisionsByEntryIdUseCase);
-        const result = await useCase.execute(model, entryId);
+    };
+    const validateEntry = async (model, id, input)=>{
+        const useCase = context.container.resolve(ValidateEntryUseCase);
+        const result = await useCase.execute(model, id || null, input);
         if (result.isFail()) {
-          const error = result.error;
-          throw new WebinyError(error.message || "Could not get entry revisions.", error.code || "GET_ENTRY_REVISIONS_ERROR", {
-            error,
-            entryId,
-            model
-          });
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not validate entry.", error.code || "VALIDATION_ERROR", error.data);
         }
         return result.value;
-      });
-    },
-    /**
-     * @internal
-     */
-    async getEntry(model, params) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntry", async () => {
-        const useCase = context.container.resolve(GetEntryUseCase);
-        const result = await useCase.execute(model, params);
+    };
+    const moveEntry = async (model, id, folderId)=>{
+        const useCase = context.container.resolve(MoveEntryUseCase);
+        const result = await useCase.execute(model, id, folderId);
         if (result.isFail()) {
-          const error = result.error;
-          throw new WebinyError(error.message || "Entry not found!", error.code || "GET_ENTRY_ERROR", {
-            error,
-            params,
-            model
-          });
+            const error = result.error;
+            throw new _webiny_error(error.message || `Could not move entry "${id}" of model "${model.modelId}".`, error.code || "MOVE_ENTRY_ERROR", error.data);
         }
         return result.value;
-      });
-    },
-    /**
-     * @description Should not be used directly. Internal use only!
-     *
-     * @internal
-     */
-    async listEntries(model, params) {
-      const useCase = context.container.resolve(ListEntriesUseCase);
-      const result = await useCase.execute(model, params);
-      if (result.isFail()) {
-        const error = result.error;
-        throw new WebinyError(error.message || "Could not list entries.", error.code || "LIST_ENTRIES_ERROR", {
-          error,
-          params,
-          model
-        });
-      }
-      const {
-        entries,
-        meta
-      } = result.value;
-      return [entries, meta];
-    },
-    async listLatestEntries(model, params) {
-      const useCase = context.container.resolve(ListLatestEntriesUseCase);
-      const result = await useCase.execute(model, params);
-      if (result.isFail()) {
-        const error = result.error;
-        throw new WebinyError(error.message || "Could not list latest entries.", error.code || "LIST_LATEST_ENTRIES_ERROR", {
-          error,
-          params,
-          model
-        });
-      }
-      const {
-        entries,
-        meta
-      } = result.value;
-      return [entries, meta];
-    },
-    async listDeletedEntries(model, params) {
-      const useCase = context.container.resolve(ListDeletedEntriesUseCase);
-      const result = await useCase.execute(model, params);
-      if (result.isFail()) {
-        const error = result.error;
-        throw new WebinyError(error.message || "Could not list deleted entries.", error.code || "LIST_DELETED_ENTRIES_ERROR", {
-          error,
-          params,
-          model
-        });
-      }
-      const {
-        entries,
-        meta
-      } = result.value;
-      return [entries, meta];
-    },
-    async listPublishedEntries(model, params) {
-      const useCase = context.container.resolve(ListPublishedEntriesUseCase);
-      const result = await useCase.execute(model, params);
-      if (result.isFail()) {
-        const error = result.error;
-        throw new WebinyError(error.message || "Could not list published entries.", error.code || "LIST_PUBLISHED_ENTRIES_ERROR", {
-          error,
-          params,
-          model
-        });
-      }
-      const {
-        entries,
-        meta
-      } = result.value;
-      return [entries, meta];
-    },
-    async createEntry(model, input, options) {
-      return context.benchmark.measure("headlessCms.crud.entries.createEntry", async () => {
-        return createEntry(model, input, options);
-      });
-    },
-    async createEntryRevisionFrom(model, sourceId, input, options) {
-      return context.benchmark.measure("headlessCms.crud.entries.createEntryRevisionFrom", async () => {
-        return createEntryRevisionFrom(model, sourceId, input, options);
-      });
-    },
-    async updateEntry(model, id, input, meta, options) {
-      return context.benchmark.measure("headlessCms.crud.entries.updateEntry", async () => {
-        return updateEntry(model, id, input, meta, options);
-      });
-    },
-    async validateEntry(model, id, input) {
-      return context.benchmark.measure("headlessCms.crud.entries.validateEntry", async () => {
-        return validateEntry(model, id, input);
-      });
-    },
-    async moveEntry(model, id, folderId) {
-      return context.benchmark.measure("headlessCms.crud.entries.moveEntry", async () => {
-        return moveEntry(model, id, folderId);
-      });
-    },
-    /**
-     * Method used internally. Not documented and should not be used in users systems.
-     * @internal
-     */
-    async republishEntry(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.republishEntry", async () => {
-        return republishEntry(model, id);
-      });
-    },
-    async deleteEntryRevision(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.deleteEntryRevision", async () => {
-        return deleteEntryRevision(model, id);
-      });
-    },
-    async deleteEntry(model, entryId, options) {
-      const deleteEntryUseCase = context.container.resolve(DeleteEntryUseCase);
-      return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
-        const result = await deleteEntryUseCase.execute(model, entryId, options ?? {});
+    };
+    const republishEntry = async (model, id)=>{
+        const useCase = context.container.resolve(RepublishEntryUseCase);
+        const result = await useCase.execute(model, id);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not republish entry.", error.code || "REPUBLISH_ERROR", error.data);
+        }
+        return result.value;
+    };
+    const deleteEntryRevision = async (model, revisionId)=>{
+        const useCase = context.container.resolve(DeleteEntryRevisionUseCase);
+        const result = await useCase.execute(model, revisionId);
+        if (result.isFail()) throw new _webiny_error(result.error.message, result.error.code, result.error.data);
+    };
+    const deleteMultipleEntries = async (model, params)=>{
+        const useCase = context.container.resolve(DeleteMultipleEntriesUseCase);
+        const result = await useCase.execute(model, params);
         if (result.isFail()) {
-          throw new WebinyError(result.error.message, result.error.code, result.error.data);
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not delete multiple entries.", error.code || "DELETE_ENTRIES_MULTIPLE_ERROR", error.data);
         }
-      });
-    },
-    async restoreEntryFromBin(model, entryId) {
-      return context.benchmark.measure("headlessCms.crud.entries.restoreEntryFromBin", async () => {
-        const useCase = context.container.resolve(RestoreEntryFromBinUseCase);
-        const result = await useCase.execute(model, entryId);
+        return result.value;
+    };
+    const publishEntry = async (model, id)=>{
+        const useCase = context.container.resolve(PublishEntryUseCase);
+        const result = await useCase.execute(model, id);
+        if (result.isFail()) throw new _webiny_error(result.error.message || "Could not publish entry.", result.error.code || "PUBLISH_ERROR", result.error.data);
+        return result.value;
+    };
+    const unpublishEntry = async (model, id)=>{
+        const useCase = context.container.resolve(UnpublishEntryUseCase);
+        const result = await useCase.execute(model, id);
         if (result.isFail()) {
-          throw new WebinyError(result.error.message, result.error.code, result.error.data);
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not unpublish entry.", error.code || "UNPUBLISH_ERROR", error.data);
         }
         return result.value;
-      });
-    },
-    async deleteMultipleEntries(model, ids) {
-      return context.benchmark.measure("headlessCms.crud.entries.deleteMultipleEntries", async () => {
-        return deleteMultipleEntries(model, ids);
-      });
-    },
-    async publishEntry(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.publishEntry", async () => {
-        return publishEntry(model, id);
-      });
-    },
-    async unpublishEntry(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.unpublishEntry", async () => {
-        return unpublishEntry(model, id);
-      });
-    },
-    async getUniqueFieldValues(model, params) {
-      return context.benchmark.measure("headlessCms.crud.entries.getUniqueFieldValues", async () => {
-        return getUniqueFieldValues(model, params);
-      });
-    }
-  };
+    };
+    const getUniqueFieldValues = async (model, params)=>{
+        const useCase = context.container.resolve(GetUniqueFieldValuesUseCase);
+        const result = await useCase.execute(model, params);
+        if (result.isFail()) throw new _webiny_error(result.error.message, result.error.code, result.error.data);
+        return result.value;
+    };
+    return {
+        async getEntriesByIds (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async ()=>{
+                const useCase = context.container.resolve(GetEntriesByIdsUseCase);
+                const result = await useCase.execute(model, ids);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Could not get entries by IDs.", error.code || "GET_ENTRIES_BY_IDS_ERROR", {
+                        error,
+                        ids,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async getEntryById (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.getEntryById", async ()=>{
+                const useCase = context.container.resolve(GetEntryByIdUseCase);
+                const result = await useCase.execute(model, id);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || `Entry by ID "${id}" not found.`, error.code || "GET_ENTRY_BY_ID_ERROR", error.data);
+                }
+                return result.value;
+            });
+        },
+        async getPublishedEntriesByIds (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async ()=>{
+                const useCase = context.container.resolve(GetPublishedEntriesByIdsUseCase);
+                const result = await useCase.execute(model, ids);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Could not get published entries by IDs.", error.code || "GET_PUBLISHED_ENTRIES_BY_IDS_ERROR", {
+                        error,
+                        ids,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async getLatestEntriesByIds (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async ()=>{
+                const useCase = context.container.resolve(GetLatestEntriesByIdsUseCase);
+                const result = await useCase.execute(model, ids);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Could not get latest entries by IDs.", error.code || "GET_LATEST_ENTRIES_BY_IDS_ERROR", {
+                        error,
+                        ids,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async getEntryRevisions (model, entryId) {
+            return context.benchmark.measure("headlessCms.crud.entries.getEntryRevisions", async ()=>{
+                const useCase = context.container.resolve(GetRevisionsByEntryIdUseCase);
+                const result = await useCase.execute(model, entryId);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Could not get entry revisions.", error.code || "GET_ENTRY_REVISIONS_ERROR", {
+                        error,
+                        entryId,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async getEntry (model, params) {
+            return context.benchmark.measure("headlessCms.crud.entries.getEntry", async ()=>{
+                const useCase = context.container.resolve(GetEntryUseCase);
+                const result = await useCase.execute(model, params);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Entry not found!", error.code || "GET_ENTRY_ERROR", {
+                        error,
+                        params,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async listEntries (model, params) {
+            const useCase = context.container.resolve(ListEntriesUseCase);
+            const result = await useCase.execute(model, params);
+            if (result.isFail()) {
+                const error = result.error;
+                throw new _webiny_error(error.message || "Could not list entries.", error.code || "LIST_ENTRIES_ERROR", {
+                    error,
+                    params,
+                    model
+                });
+            }
+            const { entries, meta } = result.value;
+            return [
+                entries,
+                meta
+            ];
+        },
+        async listLatestEntries (model, params) {
+            const useCase = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await useCase.execute(model, params);
+            if (result.isFail()) {
+                const error = result.error;
+                throw new _webiny_error(error.message || "Could not list latest entries.", error.code || "LIST_LATEST_ENTRIES_ERROR", {
+                    error,
+                    params,
+                    model
+                });
+            }
+            const { entries, meta } = result.value;
+            return [
+                entries,
+                meta
+            ];
+        },
+        async listDeletedEntries (model, params) {
+            const useCase = context.container.resolve(ListDeletedEntriesUseCase);
+            const result = await useCase.execute(model, params);
+            if (result.isFail()) {
+                const error = result.error;
+                throw new _webiny_error(error.message || "Could not list deleted entries.", error.code || "LIST_DELETED_ENTRIES_ERROR", {
+                    error,
+                    params,
+                    model
+                });
+            }
+            const { entries, meta } = result.value;
+            return [
+                entries,
+                meta
+            ];
+        },
+        async listPublishedEntries (model, params) {
+            const useCase = context.container.resolve(ListPublishedEntriesUseCase);
+            const result = await useCase.execute(model, params);
+            if (result.isFail()) {
+                const error = result.error;
+                throw new _webiny_error(error.message || "Could not list published entries.", error.code || "LIST_PUBLISHED_ENTRIES_ERROR", {
+                    error,
+                    params,
+                    model
+                });
+            }
+            const { entries, meta } = result.value;
+            return [
+                entries,
+                meta
+            ];
+        },
+        async createEntry (model, input, options) {
+            return context.benchmark.measure("headlessCms.crud.entries.createEntry", async ()=>createEntry(model, input, options));
+        },
+        async createEntryRevisionFrom (model, sourceId, input, options) {
+            return context.benchmark.measure("headlessCms.crud.entries.createEntryRevisionFrom", async ()=>createEntryRevisionFrom(model, sourceId, input, options));
+        },
+        async updateEntry (model, id, input, options) {
+            return context.benchmark.measure("headlessCms.crud.entries.updateEntry", async ()=>updateEntry(model, id, input, options));
+        },
+        async updateRevisionDescription (model, id, revisionDescription) {
+            return context.benchmark.measure("headlessCms.crud.entries.updateRevisionDescription", async ()=>updateRevisionDescription(model, id, revisionDescription));
+        },
+        async validateEntry (model, id, input) {
+            return context.benchmark.measure("headlessCms.crud.entries.validateEntry", async ()=>validateEntry(model, id, input));
+        },
+        async moveEntry (model, id, folderId) {
+            return context.benchmark.measure("headlessCms.crud.entries.moveEntry", async ()=>moveEntry(model, id, folderId));
+        },
+        async republishEntry (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.republishEntry", async ()=>republishEntry(model, id));
+        },
+        async deleteEntryRevision (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.deleteEntryRevision", async ()=>deleteEntryRevision(model, id));
+        },
+        async deleteEntry (model, entryId, options) {
+            const deleteEntryUseCase = context.container.resolve(DeleteEntryUseCase);
+            return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async ()=>{
+                const result = await deleteEntryUseCase.execute(model, entryId, options ?? {});
+                if (result.isFail()) throw new _webiny_error(result.error.message, result.error.code, result.error.data);
+            });
+        },
+        async restoreEntryFromBin (model, entryId) {
+            return context.benchmark.measure("headlessCms.crud.entries.restoreEntryFromBin", async ()=>{
+                const useCase = context.container.resolve(RestoreEntryFromBinUseCase);
+                const result = await useCase.execute(model, entryId);
+                if (result.isFail()) throw new _webiny_error(result.error.message, result.error.code, result.error.data);
+                return result.value;
+            });
+        },
+        async deleteMultipleEntries (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.deleteMultipleEntries", async ()=>deleteMultipleEntries(model, ids));
+        },
+        async publishEntry (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.publishEntry", async ()=>publishEntry(model, id));
+        },
+        async unpublishEntry (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.unpublishEntry", async ()=>unpublishEntry(model, id));
+        },
+        async getUniqueFieldValues (model, params) {
+            return context.benchmark.measure("headlessCms.crud.entries.getUniqueFieldValues", async ()=>getUniqueFieldValues(model, params));
+        }
+    };
 };
+export { createContentEntryCrud };
 
 //# sourceMappingURL=contentEntry.crud.js.map