@webiny/api-headless-cms-ddb 0.0.0-unstable.a4f3e4ea8b → 0.0.0-unstable.a85ef555b2

package/operations/entry/index.js

@@ -1,937 +0,0 @@
-import error from "@webiny/error";
-import { DataLoadersHandler } from "./dataLoaders.js";
-import { CONTENT_ENTRY_STATUS } from "@webiny/api-headless-cms/types/index.js";
-import { createEntryLatestKeys, createEntryPublishedKeys, createEntryRevisionKeys, createGSIPartitionKey, createPartitionKey, createPublishedSortKey, createRevisionSortKey } from "./keys.js";
-import { decodeCursor, encodeCursor } from "@webiny/utils";
-import { ValueFilterRegistry } from "@webiny/db-utils";
-import { aggregateUniqueFieldValues, createFields, createStorageModelAccessor, createStorageTransformCallable, filter, sort } from "@webiny/api-headless-cms-storage";
-import { isDeletedEntryMetaField, isEntryLevelEntryMetaField, isRestoredEntryMetaField, pickEntryMetaFields } from "@webiny/api-headless-cms/constants.js";
-import { StorageTransformRegistry } from "@webiny/api-headless-cms/exports/api/cms/storage.js";
-const convertToStorageEntry = (params)=>{
-    const { model, storageEntry } = params;
-    const values = model.convertValueKeyToStorage({
-        fields: model.fields,
-        values: storageEntry.values
-    });
-    return {
-        ...storageEntry,
-        values
-    };
-};
-const convertFromStorageEntry = (params)=>{
-    const { model, storageEntry } = params;
-    const values = model.convertValueKeyFromStorage({
-        fields: model.fields,
-        values: storageEntry.values
-    });
-    return {
-        ...storageEntry,
-        values
-    };
-};
-const MAX_LIST_LIMIT = 1000000;
-const createEntriesStorageOperations = (params)=>{
-    const { entity, container, plugins } = params;
-    const storageTransformRegistry = container.resolve(StorageTransformRegistry);
-    const { getModel: getStorageOperationsModel } = createStorageModelAccessor(plugins);
-    const dataLoaders = new DataLoadersHandler({
-        entity
-    });
-    const create = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const isPublished = "published" === entry.status;
-        const locked = isPublished ? true : entry.locked;
-        const storageEntry = convertToStorageEntry({
-            model,
-            storageEntry: initialStorageEntry
-        });
-        const storageEntryRevisionKeys = createEntryRevisionKeys(entry);
-        const storageEntryLatestKeys = createEntryLatestKeys(entry);
-        const entityBatch = entity.createEntityWriter({
-            put: [
-                {
-                    ...storageEntryRevisionKeys,
-                    data: {
-                        ...storageEntry,
-                        locked
-                    }
-                },
-                {
-                    ...storageEntryLatestKeys,
-                    data: {
-                        ...storageEntry,
-                        locked
-                    }
-                }
-            ]
-        });
-        if (isPublished) {
-            const storageEntryPublishedKeys = createEntryPublishedKeys(storageEntry);
-            entityBatch.put({
-                ...storageEntryPublishedKeys,
-                data: {
-                    ...storageEntry,
-                    locked
-                }
-            });
-        }
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not insert data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
-                error: ex,
-                entry
-            });
-        }
-        return initialStorageEntry;
-    };
-    const createRevisionFrom = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const storageEntry = convertToStorageEntry({
-            storageEntry: initialStorageEntry,
-            model
-        });
-        const entityBatch = entity.createEntityWriter({
-            put: [
-                {
-                    ...createEntryRevisionKeys(storageEntry),
-                    data: {
-                        ...storageEntry
-                    }
-                },
-                {
-                    ...createEntryLatestKeys(storageEntry),
-                    data: {
-                        ...storageEntry
-                    }
-                }
-            ]
-        });
-        const isPublished = "published" === entry.status;
-        if (isPublished) {
-            entityBatch.put({
-                ...createEntryPublishedKeys(storageEntry),
-                data: {
-                    ...storageEntry
-                }
-            });
-            const [publishedRevisionStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
-                model,
-                ids: [
-                    entry.id
-                ]
-            });
-            if (publishedRevisionStorageEntry) entityBatch.put({
-                ...createEntryRevisionKeys(publishedRevisionStorageEntry),
-                data: {
-                    ...publishedRevisionStorageEntry,
-                    status: CONTENT_ENTRY_STATUS.UNPUBLISHED
-                }
-            });
-        }
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
-                error: ex,
-                entry,
-                storageEntry
-            });
-        }
-        return initialStorageEntry;
-    };
-    const update = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const isPublished = "published" === entry.status;
-        const locked = isPublished ? true : entry.locked;
-        const storageEntry = convertToStorageEntry({
-            model,
-            storageEntry: initialStorageEntry
-        });
-        const entityBatch = entity.createEntityWriter({
-            put: [
-                {
-                    ...createEntryRevisionKeys(storageEntry),
-                    data: {
-                        ...storageEntry,
-                        locked
-                    }
-                }
-            ]
-        });
-        if (isPublished) entityBatch.put({
-            ...createEntryPublishedKeys(storageEntry),
-            data: {
-                ...storageEntry,
-                locked
-            }
-        });
-        const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-        if (latestStorageEntry) {
-            const updatingLatestRevision = latestStorageEntry.id === entry.id;
-            if (updatingLatestRevision) entityBatch.put({
-                ...createEntryLatestKeys(storageEntry),
-                data: {
-                    ...storageEntry,
-                    locked
-                }
-            });
-            else {
-                const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
-                entityBatch.put({
-                    ...createEntryRevisionKeys(latestStorageEntry),
-                    data: {
-                        ...latestStorageEntry,
-                        ...updatedEntryLevelMetaFields
-                    }
-                });
-                entityBatch.put({
-                    ...createEntryLatestKeys(latestStorageEntry),
-                    data: {
-                        ...latestStorageEntry,
-                        ...updatedEntryLevelMetaFields
-                    }
-                });
-            }
-        }
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-            return initialStorageEntry;
-        } catch (ex) {
-            throw new error(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
-                error: ex,
-                entry,
-                latestStorageEntry
-            });
-        }
-    };
-    const updateRevision = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const storageEntry = convertToStorageEntry({
-            model,
-            storageEntry: initialStorageEntry
-        });
-        const entityBatch = entity.createEntityWriter({
-            put: [
-                {
-                    ...createEntryRevisionKeys(storageEntry),
-                    data: storageEntry
-                }
-            ]
-        });
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-            return initialStorageEntry;
-        } catch (ex) {
-            throw new error(ex.message || "Could not update revision.", ex.code || "UPDATE_REVISION_ERROR", {
-                error: ex,
-                entry
-            });
-        }
-    };
-    const move = async (initialModel, id, folderId)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const partitionKey = createPartitionKey({
-            id,
-            tenant: model.tenant
-        });
-        const records = await entity.queryAll({
-            partitionKey,
-            options: {
-                gte: " "
-            }
-        });
-        const entityBatch = entity.createEntityWriter({
-            put: records.map((item)=>({
-                    ...item,
-                    data: {
-                        ...item.data,
-                        location: {
-                            ...item.data.location,
-                            folderId
-                        }
-                    }
-                }))
-        });
-        try {
-            await entityBatch.execute();
-        } catch (ex) {
-            throw error.from(ex, {
-                message: "Could not move records to a new folder.",
-                data: {
-                    id,
-                    folderId
-                }
-            });
-        }
-    };
-    const moveToBin = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        let records = [];
-        try {
-            records = await entity.queryAll({
-                partitionKey: createPartitionKey({
-                    id: entry.id,
-                    tenant: model.tenant
-                }),
-                options: {
-                    gte: " "
-                }
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
-                error: ex,
-                id: entry.id
-            });
-        }
-        if (0 === records.length) return;
-        const storageEntry = convertToStorageEntry({
-            model,
-            storageEntry: initialStorageEntry
-        });
-        const updatedDeletedMetaFields = pickEntryMetaFields(storageEntry, isDeletedEntryMetaField);
-        const entityBatch = entity.createEntityWriter({
-            put: records.map((record)=>({
-                    ...record,
-                    data: {
-                        ...record.data,
-                        ...updatedDeletedMetaFields,
-                        wbyDeleted: storageEntry.wbyDeleted,
-                        location: storageEntry.location,
-                        binOriginalFolderId: storageEntry.binOriginalFolderId
-                    }
-                }))
-        });
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not move the entry to the bin.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
-                error: ex,
-                entry,
-                storageEntry
-            });
-        }
-    };
-    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
-        });
-        let records = [];
-        try {
-            records = await entity.queryAll({
-                partitionKey,
-                options: {
-                    gte: " "
-                }
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
-                error: ex,
-                id
-            });
-        }
-        const entityBatch = entity.createEntityWriter({
-            delete: records.map((item)=>({
-                    PK: item.PK,
-                    SK: item.SK
-                }))
-        });
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
-                error: ex,
-                partitionKey,
-                id
-            });
-        }
-    };
-    const restoreFromBin = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        let records = [];
-        try {
-            records = await entity.queryAll({
-                partitionKey: createPartitionKey({
-                    id: entry.id,
-                    tenant: model.tenant
-                }),
-                options: {
-                    gte: " "
-                }
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
-                error: ex,
-                id: entry.id
-            });
-        }
-        if (0 === records.length) return initialStorageEntry;
-        const storageEntry = convertToStorageEntry({
-            model,
-            storageEntry: initialStorageEntry
-        });
-        const updatedRestoredMetaFields = pickEntryMetaFields(storageEntry, isRestoredEntryMetaField);
-        const entityBatch = entity.createEntityWriter({
-            put: records.map((record)=>({
-                    ...record,
-                    data: {
-                        ...record.data,
-                        ...updatedRestoredMetaFields,
-                        wbyDeleted: storageEntry.wbyDeleted,
-                        location: storageEntry.location,
-                        binOriginalFolderId: storageEntry.binOriginalFolderId
-                    }
-                }))
-        });
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-            return initialStorageEntry;
-        } catch (ex) {
-            throw new error(ex.message || "Could not restore the entry from the bin.", ex.code || "RESTORE_ENTRY_ERROR", {
-                error: ex,
-                entry,
-                storageEntry
-            });
-        }
-    };
-    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 entityBatch = entity.createEntityWriter({
-            delete: [
-                {
-                    PK: partitionKey,
-                    SK: createRevisionSortKey(entry)
-                }
-            ]
-        });
-        const publishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
-        if (publishedStorageEntry && entry.id === publishedStorageEntry.id) entityBatch.delete({
-            PK: partitionKey,
-            SK: createPublishedSortKey()
-        });
-        if (initialLatestStorageEntry) {
-            const latestStorageEntry = convertToStorageEntry({
-                storageEntry: initialLatestStorageEntry,
-                model
-            });
-            entityBatch.put({
-                ...createEntryLatestKeys(latestStorageEntry),
-                data: {
-                    ...latestStorageEntry
-                }
-            });
-            entityBatch.put({
-                ...createEntryRevisionKeys(latestStorageEntry),
-                data: {
-                    ...latestStorageEntry
-                }
-            });
-        }
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-        } catch (ex) {
-            throw new error(ex.message, ex.code, {
-                error: ex,
-                entry,
-                latestEntry
-            });
-        }
-    };
-    const deleteMultipleEntries = async (initialModel, params)=>{
-        const { entries } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const revisions = await dataLoaders.getAllEntryRevisions({
-            model,
-            ids: entries
-        });
-        const entityBatch = entity.createEntityWriter();
-        for (const id of entries){
-            const partitionKey = createPartitionKey({
-                id,
-                tenant: model.tenant
-            });
-            entityBatch.delete({
-                PK: partitionKey,
-                SK: "L"
-            });
-            entityBatch.delete({
-                PK: partitionKey,
-                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();
-    };
-    const getLatestRevisionByEntryId = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getLatestRevisionByEntryId({
-            model,
-            ids: [
-                params.id
-            ]
-        });
-        const item = items.shift() || null;
-        if (!item) return null;
-        return convertFromStorageEntry({
-            storageEntry: item,
-            model
-        });
-    };
-    const getPublishedRevisionByEntryId = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getPublishedRevisionByEntryId({
-            model,
-            ids: [
-                params.id
-            ]
-        });
-        const item = items.shift() || null;
-        if (!item) return null;
-        return convertFromStorageEntry({
-            storageEntry: item,
-            model
-        });
-    };
-    const getRevisionById = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getRevisionById({
-            model,
-            ids: [
-                params.id
-            ]
-        });
-        const item = items.shift() || null;
-        if (!item) return null;
-        return convertFromStorageEntry({
-            storageEntry: item,
-            model
-        });
-    };
-    const getRevisions = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getAllEntryRevisions({
-            model,
-            ids: [
-                params.id
-            ]
-        });
-        return items.map((item)=>convertFromStorageEntry({
-                storageEntry: item,
-                model
-            }));
-    };
-    const getByIds = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getRevisionById({
-            model,
-            ids: params.ids
-        });
-        return items.map((item)=>convertFromStorageEntry({
-                storageEntry: item,
-                model
-            }));
-    };
-    const getLatestByIds = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getLatestRevisionByEntryId({
-            model,
-            ids: params.ids
-        });
-        return items.map((item)=>convertFromStorageEntry({
-                storageEntry: item,
-                model
-            }));
-    };
-    const getPublishedByIds = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const items = await dataLoaders.getPublishedRevisionByEntryId({
-            model,
-            ids: params.ids
-        });
-        return items.map((item)=>convertFromStorageEntry({
-                storageEntry: item,
-                model
-            }));
-    };
-    const getPreviousRevision = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const { entryId, version } = params;
-        const partitionKey = createPartitionKey({
-            tenant: model.tenant,
-            id: entryId
-        });
-        const unfilteredRevisions = await entity.queryAll({
-            partitionKey,
-            options: {
-                beginsWith: "REV#",
-                reverse: true
-            }
-        });
-        const filteredRevisions = unfilteredRevisions.filter((item)=>item.data.version < version);
-        const storageEntry = filteredRevisions[0];
-        if (!storageEntry) return null;
-        try {
-            return convertFromStorageEntry({
-                storageEntry: storageEntry.data,
-                model
-            });
-        } catch (ex) {
-            throw new error(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", {
-                ...params,
-                error: ex,
-                partitionKey,
-                model
-            });
-        }
-    };
-    const list = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const { limit: initialLimit = 10, where: initialWhere, after, sort: sortBy, fields, search } = params;
-        const limit = initialLimit <= 0 || initialLimit >= MAX_LIST_LIMIT ? MAX_LIST_LIMIT : initialLimit;
-        const type = initialWhere.published ? "P" : "L";
-        const partitionKey = createGSIPartitionKey(model, type);
-        const options = {
-            index: "GSI1",
-            gte: " "
-        };
-        let storageEntries = [];
-        try {
-            storageEntries = await entity.queryAll({
-                partitionKey,
-                options
-            });
-        } catch (ex) {
-            throw new error(ex.message, "QUERY_ENTRIES_ERROR", {
-                error: ex,
-                partitionKey,
-                options
-            });
-        }
-        if (0 === storageEntries.length) return {
-            hasMoreItems: false,
-            totalCount: 0,
-            cursor: null,
-            items: []
-        };
-        const where = {
-            ...initialWhere
-        };
-        delete where["published"];
-        delete where["latest"];
-        const modelFields = createFields({
-            plugins,
-            fields: model.fields
-        });
-        const fromStorage = createStorageTransformCallable(storageTransformRegistry, model);
-        const records = await Promise.all(storageEntries.map(async (storageEntry)=>{
-            const entry = convertFromStorageEntry({
-                storageEntry: storageEntry.data,
-                model
-            });
-            for (const field of model.fields)entry.values[field.fieldId] = await fromStorage(field, entry.values[field.fieldId]);
-            return entry;
-        }));
-        const valueFilterRegistry = container.resolve(ValueFilterRegistry);
-        const filteredItems = filter({
-            items: records,
-            where,
-            plugins,
-            fields: modelFields,
-            fullTextSearch: {
-                term: search,
-                fields: fields || []
-            },
-            valueFilterRegistry
-        });
-        const totalCount = filteredItems.length;
-        const sortedItems = sort({
-            model,
-            plugins,
-            items: filteredItems,
-            sort: sortBy,
-            fields: modelFields
-        });
-        const start = parseInt(decodeCursor(after) || "0") || 0;
-        const hasMoreItems = totalCount > start + limit;
-        const end = limit > totalCount + start + limit ? void 0 : start + limit;
-        const slicedItems = sortedItems.slice(start, end);
-        const cursor = encodeCursor(`${start + limit}`);
-        return {
-            hasMoreItems,
-            totalCount,
-            cursor,
-            items: slicedItems
-        };
-    };
-    const get = async (initialModel, params)=>{
-        const model = getStorageOperationsModel(initialModel);
-        const { items } = await list(model, {
-            ...params,
-            limit: 1
-        });
-        return items.shift() || null;
-    };
-    const publish = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const initialLatestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-        if (!initialLatestStorageEntry) throw new error('Could not publish entry. Could not load latest ("L") record.', "PUBLISH_ERROR", {
-            entry
-        });
-        const initialPublishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
-        const storageEntry = convertToStorageEntry({
-            model,
-            storageEntry: initialStorageEntry
-        });
-        const entityBatch = entity.createEntityWriter({
-            put: [
-                {
-                    ...createEntryRevisionKeys(storageEntry),
-                    data: {
-                        ...storageEntry
-                    }
-                },
-                {
-                    ...createEntryPublishedKeys(storageEntry),
-                    data: {
-                        ...storageEntry
-                    }
-                }
-            ]
-        });
-        const publishedRevisionId = initialPublishedStorageEntry?.id;
-        const publishingLatestRevision = entry.id === initialLatestStorageEntry.id;
-        if (publishingLatestRevision) {
-            entityBatch.put({
-                ...createEntryLatestKeys(storageEntry),
-                data: {
-                    ...storageEntry
-                }
-            });
-            if (publishedRevisionId && publishedRevisionId !== entry.id) {
-                const publishedStorageEntry = convertToStorageEntry({
-                    storageEntry: initialPublishedStorageEntry,
-                    model
-                });
-                entityBatch.put({
-                    ...createEntryRevisionKeys(publishedStorageEntry),
-                    data: {
-                        ...publishedStorageEntry,
-                        status: CONTENT_ENTRY_STATUS.UNPUBLISHED
-                    }
-                });
-            }
-        } else {
-            const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
-            const latestStorageEntry = convertToStorageEntry({
-                storageEntry: initialLatestStorageEntry,
-                model
-            });
-            let latestRevisionStatus = latestStorageEntry.status;
-            if (latestRevisionStatus === CONTENT_ENTRY_STATUS.PUBLISHED) latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
-            const latestStorageEntryFields = {
-                ...latestStorageEntry,
-                ...updatedEntryLevelMetaFields,
-                status: latestRevisionStatus
-            };
-            entityBatch.put({
-                ...createEntryLatestKeys(latestStorageEntryFields),
-                data: {
-                    ...latestStorageEntryFields
-                }
-            });
-            entityBatch.put({
-                ...createEntryRevisionKeys(latestStorageEntryFields),
-                data: {
-                    ...latestStorageEntryFields
-                }
-            });
-            const publishedRevisionDifferentFromLatest = publishedRevisionId && publishedRevisionId !== latestStorageEntry.id;
-            if (publishedRevisionDifferentFromLatest) {
-                const publishedStorageEntry = convertToStorageEntry({
-                    storageEntry: initialPublishedStorageEntry,
-                    model
-                });
-                entityBatch.put({
-                    ...createEntryRevisionKeys(publishedStorageEntry),
-                    data: {
-                        ...publishedStorageEntry,
-                        status: CONTENT_ENTRY_STATUS.UNPUBLISHED
-                    }
-                });
-            }
-        }
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-            return initialStorageEntry;
-        } catch (ex) {
-            throw new error(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
-                entry,
-                latestStorageEntry: initialLatestStorageEntry,
-                publishedStorageEntry: initialPublishedStorageEntry
-            });
-        }
-    };
-    const unpublish = async (initialModel, params)=>{
-        const { entry, storageEntry: initialStorageEntry } = params;
-        const model = getStorageOperationsModel(initialModel);
-        const partitionKey = createPartitionKey({
-            id: entry.id,
-            tenant: model.tenant
-        });
-        const storageEntry = convertToStorageEntry({
-            storageEntry: initialStorageEntry,
-            model
-        });
-        const entityBatch = entity.createEntityWriter({
-            delete: [
-                {
-                    PK: partitionKey,
-                    SK: createPublishedSortKey()
-                }
-            ],
-            put: [
-                {
-                    ...createEntryRevisionKeys(storageEntry),
-                    data: {
-                        ...storageEntry
-                    }
-                }
-            ]
-        });
-        const initialLatestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-        if (initialLatestStorageEntry) {
-            const unpublishingLatestRevision = entry.id === initialLatestStorageEntry.id;
-            if (unpublishingLatestRevision) entityBatch.put({
-                ...createEntryLatestKeys(storageEntry),
-                data: {
-                    ...storageEntry
-                }
-            });
-            else {
-                const latestStorageEntry = convertToStorageEntry({
-                    storageEntry: initialLatestStorageEntry,
-                    model
-                });
-                const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
-                entityBatch.put({
-                    ...createEntryRevisionKeys(latestStorageEntry),
-                    data: {
-                        ...latestStorageEntry,
-                        ...updatedEntryLevelMetaFields
-                    }
-                });
-                entityBatch.put({
-                    ...createEntryLatestKeys(latestStorageEntry),
-                    data: {
-                        ...latestStorageEntry,
-                        ...updatedEntryLevelMetaFields
-                    }
-                });
-            }
-        }
-        try {
-            await entityBatch.execute();
-            dataLoaders.clearAll({
-                tenant: entry.tenant
-            });
-            return initialStorageEntry;
-        } catch (ex) {
-            throw new error(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
-                entry,
-                storageEntry
-            });
-        }
-    };
-    const getUniqueFieldValues = async (model, params)=>{
-        const { where, fieldId } = params;
-        const field = model.fields.find((f)=>f.fieldId === fieldId);
-        if (!field) throw new error('Could not find field with given "fieldId" value.', "FIELD_NOT_FOUND", {
-            fieldId
-        });
-        const { items } = await list(model, {
-            where,
-            limit: MAX_LIST_LIMIT
-        });
-        return aggregateUniqueFieldValues(items, field.fieldId);
-    };
-    return {
-        create,
-        createRevisionFrom,
-        update,
-        updateRevision,
-        move,
-        delete: deleteEntry,
-        moveToBin,
-        restoreFromBin,
-        deleteRevision,
-        deleteMultipleEntries,
-        getPreviousRevision,
-        getPublishedByIds,
-        getLatestByIds,
-        getByIds,
-        getRevisionById,
-        getPublishedRevisionByEntryId,
-        getLatestRevisionByEntryId,
-        get,
-        getRevisions,
-        publish,
-        list,
-        unpublish,
-        dataLoaders,
-        getUniqueFieldValues
-    };
-};
-export { createEntriesStorageOperations };
-
-//# sourceMappingURL=index.js.map