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

package/operations/entry/index.js

@@ -1,1266 +1,1365 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createPublishedType = exports.createLatestType = exports.createEntriesStorageOperations = void 0;
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
-var _types = require("@webiny/api-headless-cms/types");
-
-var _helpers = require("../../helpers");
-
-var _configurations = require("../../configurations");
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
-
-var _omit = _interopRequireDefault(require("lodash/omit"));
-
-var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
-
-var _dataLoaders = require("./dataLoaders");
-
-var _keys = require("./keys");
-
-var _query = require("@webiny/db-dynamodb/utils/query");
-
-var _apiElasticsearch = require("@webiny/api-elasticsearch");
-
-var _get = require("@webiny/db-dynamodb/utils/get");
-
-var _utils = require("@webiny/utils");
-
-var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-
-const createType = () => {
-  return "cms.entry";
-};
-
-const createLatestType = () => {
-  return `${createType()}.l`;
-};
-
-exports.createLatestType = createLatestType;
-
-const createPublishedType = () => {
-  return `${createType()}.p`;
-};
-
-exports.createPublishedType = createPublishedType;
-
-const getEntryData = entry => {
-  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, (0, _omit.default)(entry, ["PK", "SK", "published", "latest"])), {}, {
-    TYPE: createType(),
-    __type: createType()
-  });
-};
-
-const getESLatestEntryData = async (plugins, entry) => {
-  return (0, _apiElasticsearch.compress)(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, getEntryData(entry)), {}, {
-    latest: true,
-    TYPE: createLatestType(),
-    __type: createLatestType()
-  }));
-};
-
-const getESPublishedEntryData = async (plugins, entry) => {
-  return (0, _apiElasticsearch.compress)(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, getEntryData(entry)), {}, {
-    published: true,
-    TYPE: createPublishedType(),
-    __type: createPublishedType()
-  }));
-};
-
-const convertToStorageEntry = params => {
-  const {
-    model,
-    entry
-  } = params;
-  const values = model.convertValueKeyToStorage({
-    fields: model.fields,
-    values: entry.values
-  });
-  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
-    values
-  });
-};
-
-const convertFromStorageEntry = params => {
-  const {
-    model,
-    entry
-  } = params;
-  const values = model.convertValueKeyFromStorage({
-    fields: model.fields,
-    values: entry.values
-  });
-  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
-    values
-  });
-};
-
-const createEntriesStorageOperations = params => {
-  const {
-    entity,
-    esEntity,
-    elasticsearch,
-    plugins
-  } = params;
-  const dataLoaders = new _dataLoaders.DataLoadersHandler({
-    entity
-  });
-
-  const create = async (model, params) => {
-    const {
-      entry: initialEntry,
-      storageEntry: initialStorageEntry
-    } = params;
-    const isPublished = initialEntry.status === "published";
-    const locked = isPublished ? true : initialEntry.locked;
-    const entry = convertToStorageEntry({
-      model,
-      entry: initialEntry
-    });
-    const storageEntry = convertToStorageEntry({
-      model,
-      entry: initialStorageEntry
+import { WebinyError } from "@webiny/error";
+import { CONTENT_ENTRY_STATUS } from "@webiny/api-headless-cms/types/index.js";
+import { extractEntriesFromIndex } from "../../helpers/index.js";
+import { configurations } from "../../configurations.js";
+import { createLimit, decodeCursor, encodeCursor } from "@webiny/api-opensearch";
+import { DataLoadersHandler } from "./dataLoaders.js";
+import { createEntryLatestKeys, createEntryPublishedKeys, createEntryRevisionKeys, createLatestSortKey, createPartitionKey, createPublishedSortKey, createRevisionSortKey } from "./keys.js";
+import { getTotalCount } from "@webiny/api-opensearch/types.js";
+import { createElasticsearchBody } from "./elasticsearch/body.js";
+import { shouldIgnoreEsResponseError } from "./elasticsearch/shouldIgnoreEsResponseError.js";
+import { StorageOperationsCmsModelPlugin } from "@webiny/api-headless-cms";
+import { createTransformer } from "./transformations/index.js";
+import { convertEntryKeysFromStorage } from "./transformations/convertEntryKeys.js";
+import { isDeletedEntryMetaField, isEntryLevelEntryMetaField, isRestoredEntryMetaField, pickEntryMetaFields } from "@webiny/api-headless-cms/constants.js";
+const convertToStorageEntry = (params)=>{
+    const { model, storageEntry } = params;
+    const values = model.convertValueKeyToStorage({
+        fields: model.fields,
+        values: storageEntry.values
     });
-    const esEntry = (0, _helpers.prepareEntryToIndex)({
-      plugins,
-      model,
-      entry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
-        locked
-      })),
-      storageEntry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-        locked
-      }))
-    });
-
-    const {
-      index: esIndex
-    } = _configurations.configurations.es({
-      model
-    });
-
-    const esLatestData = await getESLatestEntryData(plugins, esEntry);
-    const esPublishedData = await getESPublishedEntryData(plugins, esEntry);
-    const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createRevisionSortKey)(entry)
+    return {
+        ...storageEntry,
+        values
     };
-    const latestKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createLatestSortKey)()
+};
+const createEntriesStorageOperations = (params)=>{
+    const { entity, esEntity, elasticsearch, plugins, fieldRegistry, fieldIndexRegistry, compressionHandler, bodyModifiers, sortModifiers, queryModifiers, valueSearchRegistry, fullTextSearches, valuesModifiers, filterRegistry } = params;
+    let storageOperationsCmsModelPlugin;
+    const getStorageOperationsCmsModelPlugin = ()=>{
+        if (storageOperationsCmsModelPlugin) return storageOperationsCmsModelPlugin;
+        storageOperationsCmsModelPlugin = plugins.oneByType(StorageOperationsCmsModelPlugin.type);
+        return storageOperationsCmsModelPlugin;
     };
-    const publishedKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createPublishedSortKey)()
+    const getStorageOperationsModel = (model)=>{
+        const plugin = getStorageOperationsCmsModelPlugin();
+        return plugin.getModel(model);
     };
-    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-      locked
-    }, revisionKeys), {}, {
-      TYPE: createType()
-    })), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-      locked
-    }, latestKeys), {}, {
-      TYPE: createLatestType()
-    }))];
-
-    if (isPublished) {
-      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-        locked
-      }, publishedKeys), {}, {
-        TYPE: createPublishedType()
-      })));
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not insert entry data into the DynamoDB table.", ex.code || "CREATE_ENTRY_ERROR", {
-        error: ex,
-        entry,
-        storageEntry
-      });
-    }
-
-    const esItems = [esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestKeys), {}, {
-      index: esIndex,
-      data: esLatestData
-    }))];
-
-    if (isPublished) {
-      esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
-        index: esIndex,
-        data: esPublishedData
-      })));
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not insert entry data into the Elasticsearch DynamoDB table.", ex.code || "CREATE_ES_ENTRY_ERROR", {
-        error: ex,
-        entry,
-        esEntry
-      });
-    }
-
-    return initialStorageEntry;
-  };
-
-  const createRevisionFrom = async (model, params) => {
-    const {
-      entry: initialEntry,
-      storageEntry: initialStorageEntry
-    } = params;
-    const entry = convertToStorageEntry({
-      model,
-      entry: initialEntry
-    });
-    const storageEntry = convertToStorageEntry({
-      model,
-      entry: initialStorageEntry
+    const dataLoaders = new DataLoadersHandler({
+        entity
     });
-    const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createRevisionSortKey)(entry)
+    const create = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const isPublished = "published" === initialEntry.status;
+        const locked = isPublished ? true : initialEntry.locked;
+        initialEntry.locked = locked;
+        initialStorageEntry.locked = locked;
+        const transformer = createTransformer({
+            fieldIndexRegistry,
+            model,
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            compressionHandler,
+            valuesModifiers
+        });
+        const { entry, storageEntry } = transformer.transformEntryKeys();
+        const esEntry = transformer.transformToIndex();
+        const { index: esIndex } = configurations.es({
+            model
+        });
+        const revisionKeys = createEntryRevisionKeys(entry);
+        const latestKeys = createEntryLatestKeys(entry);
+        const publishedKeys = createEntryPublishedKeys(entry);
+        const entityBatch = entity.createEntityWriter({
+            put: [
+                {
+                    ...revisionKeys,
+                    data: {
+                        ...storageEntry,
+                        locked
+                    }
+                },
+                {
+                    ...latestKeys,
+                    data: {
+                        ...storageEntry,
+                        locked
+                    }
+                }
+            ]
+        });
+        if (isPublished) entityBatch.put({
+            ...publishedKeys,
+            data: {
+                ...storageEntry,
+                locked
+            }
+        });
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not insert entry data into the DynamoDB table.", ex.code || "CREATE_ENTRY_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        const esLatestData = await transformer.getElasticsearchLatestEntryData();
+        const elasticsearchEntityBatch = esEntity.createEntityWriter({
+            put: [
+                {
+                    ...latestKeys,
+                    index: esIndex,
+                    data: esLatestData
+                }
+            ]
+        });
+        if (isPublished) {
+            const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+            elasticsearchEntityBatch.put({
+                ...publishedKeys,
+                index: esIndex,
+                data: esPublishedData
+            });
+        }
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not insert entry data into the Elasticsearch DynamoDB table.", ex.code || "CREATE_ES_ENTRY_ERROR", {
+                error: ex,
+                entry,
+                esEntry
+            });
+        }
+        return initialStorageEntry;
     };
-    const latestKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createLatestSortKey)()
+    const createRevisionFrom = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const transformer = createTransformer({
+            model,
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            fieldIndexRegistry,
+            compressionHandler,
+            valuesModifiers
+        });
+        const { entry, storageEntry } = transformer.transformEntryKeys();
+        const revisionKeys = createEntryRevisionKeys(entry);
+        const latestKeys = createEntryLatestKeys(entry);
+        const publishedKeys = createEntryPublishedKeys(entry);
+        const isPublished = "published" === entry.status;
+        const esLatestData = await transformer.getElasticsearchLatestEntryData();
+        const entityBatch = entity.createEntityWriter({
+            put: [
+                {
+                    ...revisionKeys,
+                    data: storageEntry
+                },
+                {
+                    ...latestKeys,
+                    data: storageEntry
+                }
+            ]
+        });
+        if (isPublished) {
+            entityBatch.put({
+                ...publishedKeys,
+                data: storageEntry
+            });
+            const [publishedRevisionStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+                model,
+                ids: [
+                    entry.id
+                ]
+            });
+            if (publishedRevisionStorageEntry) {
+                const publishedRevisionKey = createEntryRevisionKeys(publishedRevisionStorageEntry);
+                entityBatch.put({
+                    ...publishedRevisionKey,
+                    data: {
+                        ...publishedRevisionStorageEntry,
+                        status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+                    }
+                });
+            }
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not create revision from given entry in the DynamoDB table.", ex.code || "CREATE_REVISION_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        const { index: esIndex } = configurations.es({
+            model
+        });
+        const elasticsearchEntityBatch = esEntity.createEntityWriter({
+            put: [
+                {
+                    ...latestKeys,
+                    index: esIndex,
+                    data: esLatestData
+                }
+            ]
+        });
+        if (isPublished) {
+            const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+            elasticsearchEntityBatch.put({
+                ...publishedKeys,
+                index: esIndex,
+                data: esPublishedData
+            });
+        }
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
+                error: ex,
+                entry
+            });
+        }
+        return initialStorageEntry;
     };
-    const esEntry = (0, _helpers.prepareEntryToIndex)({
-      plugins,
-      model,
-      entry: (0, _cloneDeep.default)(entry),
-      storageEntry: (0, _cloneDeep.default)(storageEntry)
-    });
-    const esLatestData = await getESLatestEntryData(plugins, esEntry);
-    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-      TYPE: createType()
-    }, revisionKeys)), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-      TYPE: createLatestType()
-    }, latestKeys))];
-
-    const {
-      index
-    } = _configurations.configurations.es({
-      model
-    });
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not create revision from given entry in the DynamoDB table.", ex.code || "CREATE_REVISION_ERROR", {
-        error: ex,
-        entry,
-        storageEntry
-      });
-    }
-    /**
-     * Update the "latest" entry item in the Elasticsearch
-     */
-
-
-    try {
-      await esEntity.put((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestKeys), {}, {
-        index,
-        data: esLatestData
-      }));
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
-        error: ex,
-        entry
-      });
-    }
-    /**
-     * There are no modifications on the entry created so just return the data.
-     */
-
-
-    return initialStorageEntry;
-  };
-
-  const update = async (model, params) => {
-    const {
-      entry: initialEntry,
-      storageEntry: initialStorageEntry
-    } = params;
-    const entry = convertToStorageEntry({
-      model,
-      entry: initialEntry
-    });
-    const storageEntry = convertToStorageEntry({
-      model,
-      entry: initialStorageEntry
-    });
-    const isPublished = entry.status === "published";
-    const locked = isPublished ? true : entry.locked;
-    const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createRevisionSortKey)(entry)
+    const update = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const transformer = createTransformer({
+            valuesModifiers,
+            model,
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            fieldIndexRegistry,
+            compressionHandler
+        });
+        const { entry, storageEntry } = transformer.transformEntryKeys();
+        const isPublished = "published" === entry.status;
+        const locked = isPublished ? true : entry.locked;
+        const revisionKeys = createEntryRevisionKeys(entry);
+        const latestKeys = createEntryLatestKeys(entry);
+        const publishedKeys = createEntryPublishedKeys(entry);
+        const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+            model,
+            ids: [
+                entry.id
+            ]
+        });
+        const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+            model,
+            ids: [
+                entry.id
+            ]
+        });
+        const entityBatch = entity.createEntityWriter({
+            put: [
+                {
+                    ...revisionKeys,
+                    data: {
+                        ...storageEntry,
+                        locked
+                    }
+                }
+            ]
+        });
+        if (isPublished) entityBatch.put({
+            ...publishedKeys,
+            data: {
+                ...storageEntry,
+                locked
+            }
+        });
+        const elasticsearchEntityBatch = esEntity.createEntityWriter();
+        const { index: esIndex } = configurations.es({
+            model
+        });
+        if (latestStorageEntry) {
+            const updatingLatestRevision = latestStorageEntry.id === entry.id;
+            if (updatingLatestRevision) {
+                entityBatch.put({
+                    ...latestKeys,
+                    data: storageEntry
+                });
+                const elasticsearchLatestData = await transformer.getElasticsearchLatestEntryData();
+                elasticsearchEntityBatch.put({
+                    ...latestKeys,
+                    index: esIndex,
+                    data: elasticsearchLatestData
+                });
+            } else {
+                const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
+                const updatedLatestStorageEntry = {
+                    ...latestKeys,
+                    data: {
+                        ...latestStorageEntry,
+                        ...updatedEntryLevelMetaFields
+                    }
+                };
+                entityBatch.put({
+                    ...updatedLatestStorageEntry,
+                    PK: createPartitionKey({
+                        id: latestStorageEntry.id,
+                        tenant: model.tenant
+                    }),
+                    SK: createRevisionSortKey(latestStorageEntry)
+                });
+                entityBatch.put({
+                    ...updatedLatestStorageEntry
+                });
+                const latestEsEntry = await esEntity.getClean(latestKeys);
+                if (latestEsEntry) {
+                    const latestEsEntryDataDecompressed = await compressionHandler.decompress(latestEsEntry.data);
+                    const updatedLatestEntry = await compressionHandler.compress({
+                        ...latestEsEntryDataDecompressed,
+                        ...updatedEntryLevelMetaFields
+                    });
+                    elasticsearchEntityBatch.put({
+                        ...latestKeys,
+                        index: esIndex,
+                        data: updatedLatestEntry
+                    });
+                }
+            }
+        }
+        if (isPublished && publishedStorageEntry?.id === entry.id) {
+            const elasticsearchPublishedData = await transformer.getElasticsearchPublishedEntryData();
+            elasticsearchEntityBatch.put({
+                ...publishedKeys,
+                index: esIndex,
+                data: elasticsearchPublishedData
+            });
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not update entry DynamoDB Elasticsearch records.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
+                error: ex,
+                entry
+            });
+        }
+        return initialStorageEntry;
     };
-    const latestKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createLatestSortKey)()
+    const move = async (initialModel, id, folderId)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const partitionKey = createPartitionKey({
+            id,
+            tenant: model.tenant
+        });
+        const queryAllParams = {
+            partitionKey,
+            options: {
+                gte: " "
+            }
+        };
+        const latestSortKey = createLatestSortKey();
+        const publishedSortKey = createPublishedSortKey();
+        const records = await entity.queryAll(queryAllParams);
+        let latestRecord;
+        let publishedRecord;
+        const entityBatch = entity.createEntityWriter();
+        for (const record of records){
+            entityBatch.put({
+                ...record,
+                data: {
+                    ...record.data,
+                    location: {
+                        ...record.data.location,
+                        folderId
+                    }
+                }
+            });
+            if (record.SK === publishedSortKey) publishedRecord = record.data;
+            else if (record.SK === latestSortKey) latestRecord = record.data;
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not move all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_ERROR", {
+                error: ex,
+                id
+            });
+        }
+        const esEntityReader = esEntity.createEntityReader();
+        if (publishedRecord) esEntityReader.get({
+            PK: partitionKey,
+            SK: publishedSortKey
+        });
+        if (latestRecord) esEntityReader.get({
+            PK: partitionKey,
+            SK: latestSortKey
+        });
+        if (0 === esEntityReader.total) return;
+        const esRecords = await esEntityReader.execute();
+        const esItems = (await Promise.all(esRecords.map(async (record)=>{
+            if (!record) return null;
+            return {
+                ...record,
+                data: await compressionHandler.decompress(record.data)
+            };
+        }))).filter((item)=>!!item);
+        if (0 === esItems.length) return;
+        try {
+            const elasticsearchEntityBatch = esEntity.createEntityWriter({
+                put: await Promise.all(esItems.map(async (item)=>({
+                        ...item,
+                        data: await compressionHandler.compress({
+                            ...item.data,
+                            location: {
+                                ...item.data?.location,
+                                folderId
+                            }
+                        })
+                    })))
+            });
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not move entry DynamoDB Elasticsearch records.", ex.code || "MOVE_ES_ENTRY_ERROR", {
+                error: ex,
+                partitionKey
+            });
+        }
     };
-    const publishedKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createPublishedSortKey)()
+    const moveToBin = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const transformer = createTransformer({
+            valuesModifiers,
+            model,
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            fieldIndexRegistry,
+            compressionHandler
+        });
+        const { entry, storageEntry } = transformer.transformEntryKeys();
+        const partitionKey = createPartitionKey({
+            id: entry.id,
+            tenant: model.tenant
+        });
+        const queryAllParams = {
+            partitionKey,
+            options: {
+                gte: " "
+            }
+        };
+        const latestSortKey = createLatestSortKey();
+        const publishedSortKey = createPublishedSortKey();
+        const records = await entity.queryAll(queryAllParams);
+        const updatedEntryMetaFields = pickEntryMetaFields(entry, isDeletedEntryMetaField);
+        let latestRecord;
+        let publishedRecord;
+        const entityBatch = entity.createEntityWriter();
+        for (const record of records){
+            entityBatch.put({
+                ...record,
+                data: {
+                    ...record.data,
+                    ...updatedEntryMetaFields,
+                    wbyDeleted: storageEntry.wbyDeleted,
+                    location: storageEntry.location,
+                    binOriginalFolderId: storageEntry.binOriginalFolderId
+                }
+            });
+            if (record.SK === publishedSortKey) publishedRecord = record.data;
+            else if (record.SK === latestSortKey) latestRecord = record.data;
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could mark as deleted all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        const esEntityReader = esEntity.createEntityReader();
+        if (publishedRecord) esEntityReader.get({
+            PK: partitionKey,
+            SK: publishedSortKey
+        });
+        if (latestRecord) esEntityReader.get({
+            PK: partitionKey,
+            SK: latestSortKey
+        });
+        if (0 === esEntityReader.total) return;
+        const esRecords = await esEntityReader.execute();
+        const esItems = (await Promise.all(esRecords.map(async (record)=>{
+            if (!record) return null;
+            return {
+                ...record,
+                data: await compressionHandler.decompress(record.data)
+            };
+        }))).filter((item)=>!!item);
+        if (0 === esItems.length) return;
+        const elasticsearchEntityBatch = esEntity.createEntityWriter();
+        for (const item of esItems)elasticsearchEntityBatch.put({
+            ...item,
+            data: await compressionHandler.compress({
+                ...item.data,
+                ...updatedEntryMetaFields,
+                wbyDeleted: entry.wbyDeleted,
+                location: entry.location,
+                binOriginalFolderId: entry.binOriginalFolderId
+            })
+        });
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not mark as deleted entry records from DynamoDB Elasticsearch table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
     };
-    /**
-     * We need the latest entry to check if it needs to be updated.
-     */
-
-    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-      locked
-    }, revisionKeys), {}, {
-      TYPE: createType()
-    }))];
-
-    if (isPublished) {
-      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-        locked
-      }, publishedKeys), {}, {
-        TYPE: createPublishedType()
-      })));
-    }
-
-    const esItems = [];
-
-    const {
-      index: esIndex
-    } = _configurations.configurations.es({
-      model
-    });
-    /**
-     * Variable for the elasticsearch entry so we do not convert it more than once
-     */
-
-
-    let esEntry = undefined;
-    /**
-     * If the latest entry is the one being updated, we need to create a new latest entry records.
-     */
-
-    let elasticsearchLatestData = null;
-
-    if ((latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
-      /**
-       * First we update the regular DynamoDB table
-       */
-      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), latestKeys), {}, {
-        TYPE: (0, _keys.createLatestSortKey)()
-      })));
-      /**
-       * And then update the Elasticsearch table to propagate changes to the Elasticsearch
-       */
-
-      esEntry = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
-          locked
-        })),
-        storageEntry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-          locked
-        }))
-      });
-      elasticsearchLatestData = await getESLatestEntryData(plugins, esEntry);
-      esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestKeys), {}, {
-        index: esIndex,
-        data: elasticsearchLatestData
-      })));
-    }
-
-    let elasticsearchPublishedData = null;
-
-    if (isPublished && (publishedStorageEntry === null || publishedStorageEntry === void 0 ? void 0 : publishedStorageEntry.id) === entry.id) {
-      if (!elasticsearchLatestData) {
-        /**
-         * And then update the Elasticsearch table to propagate changes to the Elasticsearch
-         */
-        if (!esEntry) {
-          esEntry = (0, _helpers.prepareEntryToIndex)({
-            plugins,
+    const restoreFromBin = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const transformer = createTransformer({
+            valuesModifiers,
             model,
-            entry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
-              locked
-            })),
-            storageEntry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-              locked
-            }))
-          });
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            fieldIndexRegistry,
+            compressionHandler
+        });
+        const { entry, storageEntry } = transformer.transformEntryKeys();
+        const updatedEntryMetaFields = pickEntryMetaFields(entry, isRestoredEntryMetaField);
+        const partitionKey = createPartitionKey({
+            id: entry.id,
+            tenant: model.tenant
+        });
+        const queryAllParams = {
+            partitionKey,
+            options: {
+                gte: " "
+            }
+        };
+        const latestSortKey = createLatestSortKey();
+        const publishedSortKey = createPublishedSortKey();
+        const records = await entity.queryAll(queryAllParams);
+        let latestRecord;
+        let publishedRecord;
+        const entityBatch = entity.createEntityWriter();
+        for (const record of records){
+            entityBatch.put({
+                ...record,
+                data: {
+                    ...record.data,
+                    ...updatedEntryMetaFields,
+                    wbyDeleted: storageEntry.wbyDeleted,
+                    location: storageEntry.location,
+                    binOriginalFolderId: storageEntry.binOriginalFolderId
+                }
+            });
+            if (record.SK === publishedSortKey) publishedRecord = record.data;
+            else if (record.SK === latestSortKey) latestRecord = record.data;
         }
-
-        elasticsearchPublishedData = await getESPublishedEntryData(plugins, esEntry);
-      } else {
-        elasticsearchPublishedData = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, elasticsearchLatestData), {}, {
-          published: true,
-          TYPE: createPublishedType(),
-          __type: createPublishedType()
-        });
-        delete elasticsearchPublishedData.latest;
-      }
-
-      esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
-        index: esIndex,
-        data: elasticsearchPublishedData
-      })));
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
-        error: ex,
-        entry,
-        storageEntry
-      });
-    }
-
-    if (esItems.length === 0) {
-      return initialStorageEntry;
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry DynamoDB Elasticsearch records.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
-        error: ex,
-        entry
-      });
-    }
-
-    return initialStorageEntry;
-  };
-
-  const deleteEntry = async (model, params) => {
-    const {
-      entry
-    } = params;
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
-    const items = await (0, _query.queryAll)({
-      entity,
-      partitionKey,
-      options: {
-        gte: " "
-      }
-    });
-    const esItems = await (0, _query.queryAll)({
-      entity: esEntity,
-      partitionKey,
-      options: {
-        gte: " "
-      }
-    });
-    const deleteItems = items.map(item => {
-      return entity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
-      });
-    });
-    const deleteEsItems = esItems.map(item => {
-      return esEntity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
-      });
-    });
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items: deleteItems
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not delete entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
-        error: ex,
-        entry
-      });
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: deleteEsItems
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not delete entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
-        error: ex,
-        entry
-      });
-    }
-  };
-
-  const deleteRevision = async (model, params) => {
-    const {
-      entry,
-      latestEntry,
-      latestStorageEntry
-    } = params;
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
-
-    const {
-      index
-    } = _configurations.configurations.es({
-      model
-    });
-    /**
-     * We need published entry to delete it if necessary.
-     */
-
-
-    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    /**
-     * We need to delete all existing records of the given entry revision.
-     */
-
-    const items = [
-    /**
-     * Delete records of given entry revision.
-     */
-    entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry)
-    })];
-    const esItems = [];
-    /**
-     * If revision we are deleting is the published one as well, we need to delete those records as well.
-     */
-
-    if ((publishedStorageEntry === null || publishedStorageEntry === void 0 ? void 0 : publishedStorageEntry.id) === entry.id) {
-      items.push(entity.deleteBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
-      }));
-      esItems.push(entity.deleteBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
-      }));
-    }
-
-    if (latestEntry && latestStorageEntry) {
-      const esEntry = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _cloneDeep.default)(latestEntry),
-        storageEntry: (0, _cloneDeep.default)(latestStorageEntry)
-      });
-      const esLatestData = await getESLatestEntryData(plugins, esEntry);
-      /**
-       * In the end we need to set the new latest entry
-       */
-
-      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestStorageEntry), {}, {
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType()
-      })));
-      esItems.push(esEntity.putBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        index,
-        data: esLatestData
-      }));
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB table.", ex.code || "DELETE_REVISION_ERROR", {
-        error: ex,
-        entry,
-        latestEntry,
-        latestStorageEntry
-      });
-    }
-
-    if (esItems.length === 0) {
-      return;
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB Elasticsearch table.", ex.code || "DELETE_REVISION_ERROR", {
-        error: ex,
-        entry,
-        latestEntry,
-        latestStorageEntry
-      });
-    }
-  };
-
-  const list = async (model, params) => {
-    const limit = (0, _apiElasticsearch.createLimit)(params.limit, 50);
-
-    const {
-      index
-    } = _configurations.configurations.es({
-      model
-    });
-
-    try {
-      const result = await elasticsearch.indices.exists({
-        index
-      });
-
-      if (!result || !result.body) {
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not restore all entry records from in the DynamoDB table.", ex.code || "RESTORE_ENTRY_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        const esEntityReader = esEntity.createEntityReader();
+        if (publishedRecord) esEntityReader.get({
+            PK: partitionKey,
+            SK: publishedSortKey
+        });
+        if (latestRecord) esEntityReader.get({
+            PK: partitionKey,
+            SK: latestSortKey
+        });
+        const esRecords = await esEntityReader.execute();
+        const esItems = (await Promise.all(esRecords.map(async (record)=>{
+            if (!record) return null;
+            return {
+                ...record,
+                data: await compressionHandler.decompress(record.data)
+            };
+        }))).filter((item)=>!!item);
+        if (0 === esItems.length) return initialStorageEntry;
+        const elasticsearchEntityBatch = esEntity.createEntityWriter();
+        for (const item of esItems)elasticsearchEntityBatch.put({
+            ...item,
+            data: await compressionHandler.compress({
+                ...item.data,
+                ...updatedEntryMetaFields,
+                wbyDeleted: entry.wbyDeleted,
+                location: entry.location,
+                binOriginalFolderId: entry.binOriginalFolderId
+            })
+        });
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not restore entry records from DynamoDB Elasticsearch table.", ex.code || "RESTORE_ENTRY_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        return initialStorageEntry;
+    };
+    const deleteEntry = async (initialModel, params)=>{
+        const { entry } = params;
+        const id = entry.id || entry.entryId;
+        const model = getStorageOperationsModel(initialModel);
+        const partitionKey = createPartitionKey({
+            id,
+            tenant: model.tenant
+        });
+        const items = await entity.queryAll({
+            partitionKey,
+            options: {
+                gte: " "
+            }
+        });
+        const esItems = await esEntity.queryAll({
+            partitionKey,
+            options: {
+                gte: " "
+            }
+        });
+        const entityBatch = entity.createEntityWriter({
+            delete: items.map((item)=>({
+                    PK: item.PK,
+                    SK: item.SK
+                }))
+        });
+        const elasticsearchEntityBatch = esEntity.createEntityWriter({
+            delete: esItems.map((item)=>({
+                    PK: item.PK,
+                    SK: item.SK
+                }))
+        });
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not destroy entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
+                error: ex,
+                id
+            });
+        }
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not destroy entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
+                error: ex,
+                id
+            });
+        }
+    };
+    const deleteRevision = async (initialModel, params)=>{
+        const { entry, latestEntry, latestStorageEntry: initialLatestStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const partitionKey = createPartitionKey({
+            id: entry.id,
+            tenant: model.tenant
+        });
+        const { index } = configurations.es({
+            model
+        });
+        const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+            model,
+            ids: [
+                entry.id
+            ]
+        });
+        const entityBatch = entity.createEntityWriter({
+            delete: [
+                {
+                    PK: partitionKey,
+                    SK: createRevisionSortKey(entry)
+                }
+            ]
+        });
+        const elasticsearchEntityBatch = esEntity.createEntityWriter();
+        if (publishedStorageEntry?.id === entry.id) {
+            entityBatch.delete({
+                PK: partitionKey,
+                SK: createPublishedSortKey()
+            });
+            elasticsearchEntityBatch.delete({
+                PK: partitionKey,
+                SK: createPublishedSortKey()
+            });
+        }
+        if (latestEntry && initialLatestStorageEntry) {
+            const latestStorageEntry = convertToStorageEntry({
+                storageEntry: initialLatestStorageEntry,
+                model
+            });
+            const latestStorageEntryLatestKey = createEntryLatestKeys(latestStorageEntry);
+            entityBatch.put({
+                ...latestStorageEntryLatestKey,
+                data: latestStorageEntry
+            });
+            const actualRevisionEntryKey = createEntryRevisionKeys(initialLatestStorageEntry);
+            entityBatch.put({
+                ...actualRevisionEntryKey,
+                data: latestStorageEntry
+            });
+            const latestTransformer = createTransformer({
+                valuesModifiers,
+                model,
+                entry: latestEntry,
+                storageEntry: initialLatestStorageEntry,
+                fieldIndexRegistry,
+                compressionHandler
+            });
+            const esLatestData = await latestTransformer.getElasticsearchLatestEntryData();
+            const esLatestKeys = createEntryLatestKeys(latestEntry);
+            elasticsearchEntityBatch.put({
+                ...esLatestKeys,
+                index,
+                data: esLatestData
+            });
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not batch write entry records to DynamoDB table.", ex.code || "DELETE_REVISION_ERROR", {
+                error: ex,
+                entry,
+                latestEntry,
+                initialLatestStorageEntry
+            });
+        }
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not batch write entry records to DynamoDB Elasticsearch table.", ex.code || "DELETE_REVISION_ERROR", {
+                error: ex,
+                entry,
+                latestEntry,
+                initialLatestStorageEntry
+            });
+        }
+    };
+    const deleteMultipleEntries = async (initialModel, params)=>{
+        const { entries } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const revisions = await dataLoaders.getAllEntryRevisions({
+            model,
+            ids: entries
+        });
+        const entityBatch = entity.createEntityWriter();
+        const elasticsearchEntityBatch = esEntity.createEntityWriter();
+        for (const id of entries){
+            entityBatch.delete({
+                PK: createPartitionKey({
+                    id,
+                    tenant: model.tenant
+                }),
+                SK: "L"
+            });
+            elasticsearchEntityBatch.delete({
+                PK: createPartitionKey({
+                    id,
+                    tenant: model.tenant
+                }),
+                SK: "L"
+            });
+            entityBatch.delete({
+                PK: createPartitionKey({
+                    id,
+                    tenant: model.tenant
+                }),
+                SK: "P"
+            });
+            elasticsearchEntityBatch.delete({
+                PK: createPartitionKey({
+                    id,
+                    tenant: model.tenant
+                }),
+                SK: "P"
+            });
+        }
+        for (const revision of revisions)entityBatch.delete({
+            PK: createPartitionKey({
+                id: revision.id,
+                tenant: model.tenant
+            }),
+            SK: createRevisionSortKey({
+                version: revision.version
+            })
+        });
+        await entityBatch.execute();
+        await elasticsearchEntityBatch.execute();
+    };
+    const list = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const limit = createLimit(params.limit, 50);
+        const { index } = configurations.es({
+            model
+        });
+        const body = createElasticsearchBody({
+            model,
+            fieldRegistry,
+            fieldIndexRegistry,
+            bodyModifiers,
+            sortModifiers,
+            queryModifiers,
+            valueSearchRegistry,
+            fullTextSearches,
+            filterRegistry,
+            params: {
+                ...params,
+                limit,
+                after: decodeCursor(params.after)
+            },
+            plugins
+        });
+        let response;
+        try {
+            response = await elasticsearch.search({
+                index,
+                body
+            });
+        } catch (error) {
+            if (shouldIgnoreEsResponseError(error)) return {
+                hasMoreItems: false,
+                totalCount: 0,
+                cursor: null,
+                items: []
+            };
+            throw new WebinyError(error.message, error.code || "OPENSEARCH_ERROR", {
+                error,
+                index,
+                body,
+                model
+            });
+        }
+        const { hits, total } = response.body.hits;
+        const items = extractEntriesFromIndex({
+            fieldRegistry,
+            fieldIndexRegistry,
+            model,
+            entries: hits.map((item)=>item._source)
+        }).map((item)=>convertEntryKeysFromStorage({
+                model,
+                entry: item
+            }));
+        const hasMoreItems = items.length > limit;
+        if (hasMoreItems) items.pop();
+        const cursor = items.length > 0 ? encodeCursor(hits[items.length - 1].sort) || null : null;
         return {
-          hasMoreItems: false,
-          totalCount: 0,
-          cursor: null,
-          items: []
+            hasMoreItems,
+            totalCount: getTotalCount(total),
+            cursor,
+            items
         };
-      }
-    } catch (ex) {
-      throw new _error.default("Could not determine if Elasticsearch index exists.", "ELASTICSEARCH_INDEX_CHECK_ERROR", {
-        error: ex,
-        index
-      });
-    }
-
-    const body = (0, _helpers.createElasticsearchQueryBody)({
-      model,
-      args: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-        limit
-      }),
-      plugins,
-      parentPath: "values"
-    });
-    let response;
-
-    try {
-      response = await elasticsearch.search({
-        index,
-        body
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message, ex.code || "ELASTICSEARCH_ERROR", {
-        error: ex,
-        index,
-        body,
-        model
-      });
-    }
-
-    const {
-      hits,
-      total
-    } = response.body.hits;
-    const items = (0, _helpers.extractEntriesFromIndex)({
-      plugins,
-      model,
-      entries: hits.map(item => item._source)
-    }).map(item => {
-      return convertFromStorageEntry({
-        model,
-        entry: item
-      });
-    });
-    const hasMoreItems = items.length > limit;
-
-    if (hasMoreItems) {
-      /**
-       * Remove the last item from results, we don't want to include it.
-       */
-      items.pop();
-    }
-    /**
-     * Cursor is the `sort` value of the last item in the array.
-     * https://www.elastic.co/guide/en/elasticsearch/reference/current/paginate-search-results.html#search-after
-     */
-
-
-    const cursor = items.length > 0 ? (0, _apiElasticsearch.encodeCursor)(hits[items.length - 1].sort) || null : null;
-    return {
-      hasMoreItems,
-      totalCount: total.value,
-      cursor,
-      items
     };
-  };
-
-  const get = async (model, params) => {
-    const {
-      items
-    } = await list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-      limit: 1
-    }));
-    return items.shift() || null;
-  };
-
-  const publish = async (model, params) => {
-    const {
-      entry: initialEntry,
-      storageEntry: initialStorageEntry
-    } = params;
-    const entry = convertToStorageEntry({
-      model,
-      entry: initialEntry
-    });
-    const storageEntry = convertToStorageEntry({
-      model,
-      entry: initialStorageEntry
-    });
-    /**
-     * We need currently published entry to check if need to remove it.
-     */
-
-    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createRevisionSortKey)(entry)
+    const get = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const { items } = await list(model, {
+            ...params,
+            limit: 1
+        });
+        return items.shift() || null;
     };
-    const latestKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createLatestSortKey)()
+    const publish = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const transformer = createTransformer({
+            valuesModifiers,
+            model,
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            fieldIndexRegistry,
+            compressionHandler
+        });
+        const { entry, storageEntry } = transformer.transformEntryKeys();
+        const revisionKeys = createEntryRevisionKeys(entry);
+        const latestKeys = createEntryLatestKeys(entry);
+        const publishedKeys = createEntryPublishedKeys(entry);
+        let latestEsEntry = null;
+        try {
+            latestEsEntry = await esEntity.getClean(latestKeys);
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not read Elasticsearch latest data.", ex.code || "PUBLISH_LATEST_READ", {
+                error: ex,
+                latestKeys: latestKeys,
+                publishedKeys: publishedKeys
+            });
+        }
+        if (!latestEsEntry) throw new WebinyError('Could not publish entry. Could not load latest ("L") record (ES table).', "PUBLISH_ERROR", {
+            entry
+        });
+        const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+            model,
+            ids: [
+                entry.id
+            ]
+        });
+        if (!latestStorageEntry) throw new WebinyError('Could not publish entry. Could not load latest ("L") record.', "PUBLISH_ERROR", {
+            entry
+        });
+        const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+            model,
+            ids: [
+                entry.id
+            ]
+        });
+        const entityBatch = entity.createEntityWriter({
+            put: [
+                {
+                    ...revisionKeys,
+                    data: storageEntry
+                },
+                {
+                    ...publishedKeys,
+                    data: storageEntry
+                }
+            ]
+        });
+        const elasticsearchEntityWriter = esEntity.createEntityWriter();
+        const { index: esIndex } = configurations.es({
+            model
+        });
+        const publishedRevisionId = publishedStorageEntry?.id;
+        const publishingLatestRevision = latestStorageEntry?.id === entry.id;
+        if (publishingLatestRevision) {
+            entityBatch.put({
+                ...latestKeys,
+                data: storageEntry
+            });
+            if (publishedStorageEntry) {
+                const isRepublishing = publishedStorageEntry.id === entry.id;
+                if (!isRepublishing) {
+                    const publishedStorageEntryKeys = createEntryRevisionKeys(publishedStorageEntry);
+                    entityBatch.put({
+                        ...publishedStorageEntryKeys,
+                        data: {
+                            ...publishedStorageEntry,
+                            status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+                        }
+                    });
+                }
+            }
+        } else {
+            const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
+            let latestRevisionStatus = latestStorageEntry.status;
+            if (latestRevisionStatus === CONTENT_ENTRY_STATUS.PUBLISHED) latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
+            const latestStorageEntryFields = {
+                ...latestStorageEntry,
+                ...updatedEntryLevelMetaFields,
+                status: latestRevisionStatus
+            };
+            const latestStorageEntryLatestKeys = createEntryLatestKeys(latestStorageEntry);
+            entityBatch.put({
+                ...latestStorageEntryLatestKeys,
+                data: latestStorageEntryFields
+            });
+            const latestStorageEntryRevisionKeys = createEntryRevisionKeys(latestStorageEntry);
+            entityBatch.put({
+                ...latestStorageEntryRevisionKeys,
+                data: latestStorageEntryFields
+            });
+            if (publishedStorageEntry) {
+                const isRepublishing = publishedStorageEntry.id === entry.id;
+                const publishedRevisionDifferentFromLatest = publishedRevisionId !== latestStorageEntry.id;
+                if (!isRepublishing && publishedRevisionDifferentFromLatest) {
+                    const publishedStorageEntryRevisionKeys = createEntryRevisionKeys(publishedStorageEntry);
+                    entityBatch.put({
+                        ...publishedStorageEntryRevisionKeys,
+                        data: {
+                            ...publishedStorageEntry,
+                            status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+                        }
+                    });
+                }
+            }
+        }
+        const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+        elasticsearchEntityWriter.put({
+            ...publishedKeys,
+            index: esIndex,
+            data: esPublishedData
+        });
+        const latestEsEntryDataDecompressed = await compressionHandler.decompress(latestEsEntry.data);
+        if (publishingLatestRevision) {
+            const updatedMetaFields = pickEntryMetaFields(entry);
+            const latestTransformer = createTransformer({
+                valuesModifiers,
+                model,
+                transformedToIndex: {
+                    ...latestEsEntryDataDecompressed,
+                    status: CONTENT_ENTRY_STATUS.PUBLISHED,
+                    locked: true,
+                    ...updatedMetaFields
+                },
+                fieldIndexRegistry,
+                compressionHandler
+            });
+            const esEntryLatestKeys = createEntryLatestKeys(latestEsEntryDataDecompressed);
+            elasticsearchEntityWriter.put({
+                index: esIndex,
+                data: await latestTransformer.getElasticsearchLatestEntryData(),
+                ...esEntryLatestKeys
+            });
+        } else {
+            const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
+            const latestEsEntry = await esEntity.getClean(latestKeys);
+            if (latestEsEntry) {
+                const latestEsEntryDataDecompressed = await compressionHandler.decompress(latestEsEntry.data);
+                let latestRevisionStatus = latestEsEntryDataDecompressed.status;
+                if (latestRevisionStatus === CONTENT_ENTRY_STATUS.PUBLISHED) latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
+                const updatedLatestEntry = await compressionHandler.compress({
+                    ...latestEsEntryDataDecompressed,
+                    ...updatedEntryLevelMetaFields,
+                    status: latestRevisionStatus
+                });
+                elasticsearchEntityWriter.put({
+                    ...latestKeys,
+                    index: esIndex,
+                    data: updatedLatestEntry
+                });
+            }
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not store publish entry records in DynamoDB table.", ex.code || "PUBLISH_ERROR", {
+                error: ex,
+                entry,
+                latestStorageEntry,
+                publishedStorageEntry
+            });
+        }
+        try {
+            await elasticsearchEntityWriter.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not store publish entry records in DynamoDB Elasticsearch table.", ex.code || "PUBLISH_ES_ERROR", {
+                error: ex,
+                entry,
+                latestStorageEntry,
+                publishedStorageEntry
+            });
+        }
+        return initialStorageEntry;
     };
-    const publishedKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createPublishedSortKey)()
+    const unpublish = async (initialModel, params)=>{
+        const { entry: initialEntry, storageEntry: initialStorageEntry } = params;
+        const model = getStorageOperationsModel(initialModel);
+        const transformer = createTransformer({
+            valuesModifiers,
+            model,
+            entry: initialEntry,
+            storageEntry: initialStorageEntry,
+            fieldIndexRegistry,
+            compressionHandler
+        });
+        const { entry, storageEntry } = await transformer.transformEntryKeys();
+        const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+            model,
+            ids: [
+                entry.id
+            ]
+        });
+        const partitionKey = createPartitionKey({
+            id: entry.id,
+            tenant: model.tenant
+        });
+        const entryRevisionKeys = createEntryRevisionKeys(entry);
+        const entityBatch = entity.createEntityWriter({
+            put: [
+                {
+                    ...entryRevisionKeys,
+                    data: storageEntry
+                }
+            ],
+            delete: [
+                {
+                    PK: partitionKey,
+                    SK: createPublishedSortKey()
+                }
+            ]
+        });
+        const elasticsearchEntityBatch = esEntity.createEntityWriter({
+            delete: [
+                {
+                    PK: partitionKey,
+                    SK: createPublishedSortKey()
+                }
+            ]
+        });
+        if (latestStorageEntry?.id === entry.id) {
+            const { index } = configurations.es({
+                model
+            });
+            const entryLatestKeys = createEntryLatestKeys(storageEntry);
+            entityBatch.put({
+                ...entryLatestKeys,
+                data: storageEntry
+            });
+            const esLatestData = await transformer.getElasticsearchLatestEntryData();
+            elasticsearchEntityBatch.put({
+                index,
+                data: esLatestData,
+                ...entryLatestKeys
+            });
+        }
+        try {
+            await entityBatch.execute();
+            dataLoaders.clearAll({
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not store unpublished entry records in DynamoDB table.", ex.code || "UNPUBLISH_ERROR", {
+                entry,
+                storageEntry
+            });
+        }
+        try {
+            await elasticsearchEntityBatch.execute();
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
+                entry,
+                storageEntry
+            });
+        }
+        return initialStorageEntry;
     };
-    let latestEsEntry = null;
-
-    try {
-      latestEsEntry = await (0, _get.get)({
-        entity: esEntity,
-        keys: latestKeys
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read Elasticsearch latest or published data.", ex.code || "PUBLISH_BATCH_READ", {
-        error: ex,
-        latestKeys: latestKeys,
-        publishedKeys: publishedKeys
-      });
-    }
-
-    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), revisionKeys), {}, {
-      TYPE: createType()
-    }))];
-    const esItems = [];
-
-    const {
-      index
-    } = _configurations.configurations.es({
-      model
-    });
-
-    if (publishedStorageEntry && publishedStorageEntry.id !== entry.id) {
-      /**
-       * If there is a `published` entry already, we need to set it to `unpublished`. We need to
-       * execute two updates: update the previously published entry's status and the published entry record.
-       * DynamoDB does not support `batchUpdate` - so here we load the previously published
-       * entry's data to update its status within a batch operation. If, hopefully,
-       * they introduce a true update batch operation, remove this `read` call.
-       */
-      const [previouslyPublishedEntry] = await dataLoaders.getRevisionById({
-        model,
-        ids: [publishedStorageEntry.id]
-      }); //
-      // const previouslyPublishedEntry = convertToStorageEntry({
-      //     model,
-      //     entry: initialPreviouslyPublishedEntry
-      // });
-
-      items.push(
-      /**
-       * Update currently published entry (unpublish it)
-       */
-      entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, previouslyPublishedEntry), {}, {
-        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
-        savedOn: entry.savedOn,
-        TYPE: createType(),
-        PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
-        SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry)
-      })));
-    }
-    /**
-     * Update the helper item in DB with the new published entry
-     */
-
-
-    items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), publishedKeys), {}, {
-      TYPE: createPublishedType()
-    })));
-    /**
-     * We need the latest entry to check if it needs to be updated as well in the Elasticsearch.
-     */
-
-    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-
-    if ((latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
-      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), latestKeys)));
-    }
-    /**
-     * If we are publishing the latest revision, let's also update the latest revision's status in ES.
-     */
-
-
-    if (latestEsEntry && (latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
-      /**
-       * Need to decompress the data from Elasticsearch DynamoDB table.
-       *
-       * No need to transform it for the storage because it was fetched directly from the Elasticsearch table, where it sits transformed.
-       */
-      const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
-      esItems.push(esEntity.putBatch({
-        index,
-        PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
-        SK: (0, _keys.createLatestSortKey)(),
-        data: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestEsEntryDataDecompressed), {}, {
-          status: _types.CONTENT_ENTRY_STATUS.PUBLISHED,
-          locked: true,
-          savedOn: entry.savedOn,
-          publishedOn: entry.publishedOn
-        })
-      }));
-    }
-
-    const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
-      plugins,
-      model,
-      entry: (0, _cloneDeep.default)(entry),
-      storageEntry: (0, _cloneDeep.default)(storageEntry)
-    });
-    /**
-     * Update the published revision entry in ES.
-     */
-
-    const esLatestData = await getESPublishedEntryData(plugins, preparedEntryData);
-    esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
-      index,
-      data: esLatestData
-    })));
-    /**
-     * Finally, execute regular table batch.
-     */
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store publish entry records in DynamoDB table.", ex.code || "PUBLISH_ERROR", {
-        error: ex,
-        entry,
-        latestStorageEntry,
-        publishedStorageEntry
-      });
-    }
-    /**
-     * And Elasticsearch table batch.
-     */
-
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store publish entry records in DynamoDB Elasticsearch table.", ex.code || "PUBLISH_ES_ERROR", {
-        error: ex,
-        entry,
-        latestStorageEntry,
-        publishedStorageEntry
-      });
-    }
-
-    return initialStorageEntry;
-  };
-
-  const unpublish = async (model, params) => {
-    const {
-      entry: initialEntry,
-      storageEntry: initialStorageEntry
-    } = params;
-    const entry = convertToStorageEntry({
-      model,
-      entry: initialEntry
-    });
-    const storageEntry = convertToStorageEntry({
-      model,
-      entry: initialStorageEntry
-    });
-    /**
-     * We need the latest entry to check if it needs to be updated.
-     */
-
-    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
-    const items = [entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    }), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType()
-    }))];
-    const esItems = [esEntity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    })];
-    /**
-     * If we are unpublishing the latest revision, let's also update the latest revision entry's status in ES.
-     */
-
-    if ((latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
-      const {
-        index
-      } = _configurations.configurations.es({
-        model
-      });
-
-      const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _cloneDeep.default)(entry),
-        storageEntry: (0, _cloneDeep.default)(storageEntry)
-      });
-      const esLatestData = await getESLatestEntryData(plugins, preparedEntryData);
-      esItems.push(esEntity.putBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        index,
-        data: esLatestData
-      }));
-    }
-    /**
-     * Finally, execute regular table batch.
-     */
-
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB table.", ex.code || "UNPUBLISH_ERROR", {
-        entry,
-        storageEntry
-      });
-    }
-    /**
-     * And Elasticsearch table batch.
-     */
-
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
-        entry,
-        storageEntry
-      });
-    }
-
-    return initialStorageEntry;
-  };
-
-  const getLatestRevisionByEntryId = async (model, params) => {
-    const [entry] = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: [params.id]
-    });
-
-    if (!entry) {
-      return null;
-    }
-
-    return convertFromStorageEntry({
-      model,
-      entry
-    });
-  };
-
-  const getPublishedRevisionByEntryId = async (model, params) => {
-    const [entry] = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: [params.id]
-    });
-
-    if (!entry) {
-      return null;
-    }
-
-    return convertFromStorageEntry({
-      model,
-      entry
-    });
-  };
-
-  const getRevisionById = async (model, params) => {
-    const [entry] = await dataLoaders.getRevisionById({
-      model,
-      ids: [params.id]
-    });
-
-    if (!entry) {
-      return null;
-    }
-
-    return convertFromStorageEntry({
-      model,
-      entry
-    });
-  };
-
-  const getRevisions = async (model, params) => {
-    const entries = await dataLoaders.getAllEntryRevisions({
-      model,
-      ids: [params.id]
-    });
-    return entries.map(entry => {
-      return convertFromStorageEntry({
-        model,
-        entry
-      });
-    });
-  };
-
-  const getByIds = async (model, params) => {
-    const entries = await dataLoaders.getRevisionById({
-      model,
-      ids: params.ids
-    });
-    return entries.map(entry => {
-      return convertFromStorageEntry({
-        model,
-        entry
-      });
-    });
-  };
-
-  const getLatestByIds = async (model, params) => {
-    const entries = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: params.ids
-    });
-    return entries.map(entry => {
-      return convertFromStorageEntry({
-        model,
-        entry
-      });
-    });
-  };
-
-  const getPublishedByIds = async (model, params) => {
-    const entries = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: params.ids
-    });
-    return entries.map(entry => {
-      return convertFromStorageEntry({
-        model,
-        entry
-      });
-    });
-  };
-
-  const getPreviousRevision = async (model, params) => {
-    const {
-      tenant,
-      locale
-    } = model;
-    const {
-      entryId,
-      version
-    } = params;
-    const queryParams = {
-      entity,
-      partitionKey: (0, _keys.createPartitionKey)({
-        tenant,
-        locale,
-        id: entryId
-      }),
-      options: {
-        lt: `REV#${(0, _utils.zeroPad)(version)}`,
-
-        /**
-         * We need to have extra checks because DynamoDB will return published or latest record if there is no REV# record.
-         */
-        filters: [{
-          attr: "TYPE",
-          eq: createType()
-        }, {
-          attr: "version",
-          lt: version
-        }],
-        reverse: true
-      }
+    const getLatestRevisionByEntryId = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const [entry] = await dataLoaders.getLatestRevisionByEntryId({
+            model,
+            ids: [
+                params.id
+            ]
+        });
+        if (!entry) return null;
+        return convertEntryKeysFromStorage({
+            model,
+            entry
+        });
+    };
+    const getPublishedRevisionByEntryId = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const [entry] = await dataLoaders.getPublishedRevisionByEntryId({
+            model,
+            ids: [
+                params.id
+            ]
+        });
+        if (!entry) return null;
+        return convertEntryKeysFromStorage({
+            model,
+            entry
+        });
+    };
+    const getRevisionById = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const [entry] = await dataLoaders.getRevisionById({
+            model,
+            ids: [
+                params.id
+            ]
+        });
+        if (!entry) return null;
+        return convertEntryKeysFromStorage({
+            model,
+            entry
+        });
+    };
+    const getRevisions = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const entries = await dataLoaders.getAllEntryRevisions({
+            model,
+            ids: [
+                params.id
+            ]
+        });
+        return entries.map((entry)=>convertEntryKeysFromStorage({
+                model,
+                entry
+            }));
+    };
+    const getByIds = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const entries = await dataLoaders.getRevisionById({
+            model,
+            ids: params.ids
+        });
+        return entries.map((entry)=>convertEntryKeysFromStorage({
+                model,
+                entry
+            }));
+    };
+    const getLatestByIds = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const entries = await dataLoaders.getLatestRevisionByEntryId({
+            model,
+            ids: params.ids
+        });
+        return entries.map((entry)=>convertEntryKeysFromStorage({
+                model,
+                entry
+            }));
+    };
+    const getPublishedByIds = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const entries = await dataLoaders.getPublishedRevisionByEntryId({
+            model,
+            ids: params.ids
+        });
+        return entries.map((entry)=>convertEntryKeysFromStorage({
+                model,
+                entry
+            }));
+    };
+    const getPreviousRevision = async (initialModel, params)=>{
+        const model = getStorageOperationsModel(initialModel);
+        const { tenant } = model;
+        const { entryId, version } = params;
+        const partitionKey = createPartitionKey({
+            tenant,
+            id: entryId
+        });
+        const options = {
+            beginsWith: "REV#",
+            reverse: true
+        };
+        try {
+            const unfilteredEntries = (await entity.queryAll({
+                partitionKey,
+                options
+            })).map((item)=>item.data);
+            const entries = unfilteredEntries.filter((item)=>item.version < version);
+            const entry = entries[0];
+            if (!entry) return null;
+            return convertEntryKeysFromStorage({
+                entry,
+                model
+            });
+        } catch (ex) {
+            throw new WebinyError(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", {
+                ...params,
+                error: ex,
+                partitionKey,
+                options,
+                model
+            });
+        }
+    };
+    const getUniqueFieldValues = async (model, params)=>{
+        const { where, fieldId } = params;
+        const { index } = configurations.es({
+            model
+        });
+        const initialBody = createElasticsearchBody({
+            model,
+            fieldRegistry,
+            fieldIndexRegistry,
+            bodyModifiers,
+            sortModifiers,
+            queryModifiers,
+            valueSearchRegistry,
+            fullTextSearches,
+            filterRegistry,
+            params: {
+                limit: 1,
+                where
+            },
+            plugins
+        });
+        const field = model.fields.find((f)=>f.fieldId === fieldId);
+        if (!field) throw new WebinyError('Could not find field with given "fieldId" value.', "FIELD_NOT_FOUND", {
+            fieldId
+        });
+        const body = {
+            ...initialBody,
+            size: 0,
+            aggregations: {
+                getUniqueFieldValues: {
+                    terms: {
+                        field: `values.${field.storageId}.keyword`,
+                        size: 1000000
+                    }
+                }
+            }
+        };
+        let response;
+        try {
+            response = await elasticsearch.search({
+                index,
+                body
+            });
+        } catch (error) {
+            if (shouldIgnoreEsResponseError(error)) return [];
+            throw new WebinyError(error.message || "Error in the Elasticsearch query.", error.code || "OPENSEARCH_ERROR", {
+                error,
+                index,
+                model,
+                body
+            });
+        }
+        const aggregations = response.body.aggregations || {};
+        const agg = aggregations["getUniqueFieldValues"];
+        const buckets = agg && "buckets" in agg && Array.isArray(agg.buckets) ? agg.buckets : [];
+        return buckets.map((bucket)=>({
+                value: bucket.key,
+                count: bucket.doc_count
+            }));
+    };
+    return {
+        create,
+        createRevisionFrom,
+        update,
+        move,
+        delete: deleteEntry,
+        moveToBin,
+        restoreFromBin,
+        deleteRevision,
+        deleteMultipleEntries,
+        get,
+        publish,
+        unpublish,
+        list,
+        getLatestRevisionByEntryId,
+        getPublishedRevisionByEntryId,
+        getRevisionById,
+        getRevisions,
+        getByIds,
+        getLatestByIds,
+        getPublishedByIds,
+        getPreviousRevision,
+        getUniqueFieldValues,
+        dataLoaders
     };
-
-    try {
-      const result = await (0, _query.queryOne)(queryParams);
-      const entry = (0, _cleanup.cleanupItem)(entity, result);
-
-      if (!entry) {
-        return null;
-      }
-
-      return convertFromStorageEntry({
-        entry,
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-        error: ex,
-        partitionKey: queryParams.partitionKey,
-        options: queryParams.options,
-        model
-      }));
-    }
-  };
-
-  return {
-    create,
-    createRevisionFrom,
-    update,
-    delete: deleteEntry,
-    deleteRevision,
-    get,
-    publish,
-    unpublish,
-    list,
-    getLatestRevisionByEntryId,
-    getPublishedRevisionByEntryId,
-    getRevisionById,
-    getRevisions,
-    getByIds,
-    getLatestByIds,
-    getPublishedByIds,
-    getPreviousRevision
-  };
 };
+export { createEntriesStorageOperations };
 
-exports.createEntriesStorageOperations = createEntriesStorageOperations;
+//# sourceMappingURL=index.js.map