@strapi/core 0.0.0-experimental.80cf2c74a2003f3c0602abc81888dd9f36dc68a3 → 0.0.0-experimental.80d3ba906e416cd717a3e334f2905460b7648735

package/dist/services/document-service/repository.js

@@ -1,297 +1,372 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const _ = require("lodash/fp");
-const strapiUtils = require("@strapi/utils");
-const common = require("./common.js");
-const draftAndPublish = require("./draft-and-publish.js");
-const internationalization = require("./internationalization.js");
-const idTransform = require("./transform/id-transform.js");
-const components = require("../entity-service/components.js");
-const params = require("../entity-service/params.js");
-const index = require("../entity-validator/index.js");
-const index$1 = require("../entity-service/attributes/index.js");
-const transformContentTypesToModels = require("../../utils/transform-content-types-to-models.js");
-const populate = require("./utils/populate.js");
-const data = require("./transform/data.js");
-const transformParamsToQuery = _.curry((uid, params2) => {
-  const query = strapiUtils.convertQueryParams.transformParamsToQuery(uid, params2);
-  return _.assoc("where", { ...params2?.lookup, ...query.where }, query);
-});
-const createContentTypeRepository = (uid) => {
-  const contentType = strapi.contentType(uid);
-  const hasDraftAndPublish = strapiUtils.contentTypes.hasDraftAndPublish(contentType);
-  async function findMany(params2 = {}) {
-    const query = await strapiUtils.async.pipe(
-      draftAndPublish.defaultToDraft,
-      draftAndPublish.statusToLookup(contentType),
-      internationalization.defaultLocale(contentType),
-      internationalization.localeToLookup(contentType),
-      idTransform.transformParamsDocumentId(uid),
-      transformParamsToQuery(uid)
-    )(params2 || {});
-    return strapi.db.query(uid).findMany(query);
-  }
-  async function findFirst(params2 = {}) {
-    const query = await strapiUtils.async.pipe(
-      draftAndPublish.defaultToDraft,
-      draftAndPublish.statusToLookup(contentType),
-      internationalization.defaultLocale(contentType),
-      internationalization.localeToLookup(contentType),
-      idTransform.transformParamsDocumentId(uid),
-      transformParamsToQuery(uid)
-    )(params2);
-    return strapi.db.query(uid).findOne(query);
-  }
-  async function findOne(documentId, params2 = {}) {
-    const query = await strapiUtils.async.pipe(
-      draftAndPublish.defaultToDraft,
-      draftAndPublish.statusToLookup(contentType),
-      internationalization.defaultLocale(contentType),
-      internationalization.localeToLookup(contentType),
-      idTransform.transformParamsDocumentId(uid),
-      transformParamsToQuery(uid),
-      (query2) => _.assoc("where", { ...query2.where, documentId }, query2)
-    )(params2);
-    return strapi.db.query(uid).findOne(query);
-  }
-  async function deleteEntry(id) {
-    const componentsToDelete = await components.getComponents(uid, { id });
-    await strapi.db.query(uid).delete({ where: { id } });
-    await components.deleteComponents(uid, componentsToDelete, { loadComponents: false });
-  }
-  async function deleteFn(documentId, params2 = {}) {
-    const query = await strapiUtils.async.pipe(
-      _.omit("status"),
-      internationalization.defaultLocale(contentType),
-      internationalization.multiLocaleToLookup(contentType),
-      transformParamsToQuery(uid),
-      (query2) => _.assoc("where", { ...query2.where, documentId }, query2)
-    )(params2);
-    if (params2.status === "draft") {
-      throw new Error("Cannot delete a draft document");
+'use strict';
+
+var fp = require('lodash/fp');
+var strapiUtils = require('@strapi/utils');
+var common = require('./common.js');
+var draftAndPublish = require('./draft-and-publish.js');
+var internationalization = require('./internationalization.js');
+var components = require('./components.js');
+var entries = require('./entries.js');
+var params = require('./params.js');
+var transformContentTypesToModels = require('../../utils/transform-content-types-to-models.js');
+var populate = require('./utils/populate.js');
+var query = require('./transform/query.js');
+var idTransform = require('./transform/id-transform.js');
+var events = require('./events.js');
+var unidirectionalRelations = require('./utils/unidirectional-relations.js');
+var bidirectionalRelations = require('./utils/bidirectional-relations.js');
+var index = require('../entity-validator/index.js');
+var firstPublishedAt = require('./first-published-at.js');
+
+const { validators } = strapiUtils.validate;
+// we have to typecast to reconcile the differences between validator and database getModel
+const getModel = (schema)=>strapi.getModel(schema);
+const createContentTypeRepository = (uid, validator = index)=>{
+    const contentType = strapi.contentType(uid);
+    const hasDraftAndPublish = strapiUtils.contentTypes.hasDraftAndPublish(contentType);
+    // Define the validations that should be performed
+    const sortValidations = [
+        'nonAttributesOperators',
+        'dynamicZones',
+        'morphRelations'
+    ];
+    const fieldValidations = [
+        'scalarAttributes'
+    ];
+    const filtersValidations = [
+        'nonAttributesOperators',
+        'dynamicZones',
+        'morphRelations'
+    ];
+    const populateValidations = {
+        sort: sortValidations,
+        field: fieldValidations,
+        filters: filtersValidations,
+        populate: [
+            'nonAttributesOperators'
+        ]
+    };
+    const validateParams = async (params)=>{
+        const ctx = {
+            schema: contentType,
+            getModel
+        };
+        await validators.validateFilters(ctx, params.filters, filtersValidations);
+        await validators.validateSort(ctx, params.sort, sortValidations);
+        await validators.validateFields(ctx, params.fields, fieldValidations);
+        await validators.validatePopulate(ctx, params.populate, populateValidations);
+        // Strip lookup from params, it's only used internally
+        if (params.lookup) {
+            throw new strapiUtils.errors.ValidationError("Invalid params: 'lookup'");
+        }
+        // TODO: add validate status, locale, pagination
+        return params;
+    };
+    const entries$1 = entries.createEntriesService(uid, validator);
+    const eventManager = events.createEventManager(strapi, uid);
+    const emitEvent = fp.curry(eventManager.emitEvent);
+    async function findMany(params = {}) {
+        const query$1 = await strapiUtils.async.pipe(validateParams, draftAndPublish.defaultToDraft, draftAndPublish.statusToLookup(contentType), internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType), idTransform.transformParamsDocumentId(uid), query.transformParamsToQuery(uid))(params || {});
+        return strapi.db.query(uid).findMany(query$1);
     }
-    const entriesToDelete = await strapi.db.query(uid).findMany(query);
-    await strapiUtils.async.map(entriesToDelete, (entryToDelete) => deleteEntry(entryToDelete.id));
-    return { deletedEntries: entriesToDelete };
-  }
-  async function createEntry(params$1 = {}) {
-    const { data: data2, ...restParams } = await idTransform.transformParamsDocumentId(uid, params$1);
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(restParams));
-    if (!data2) {
-      throw new Error("Create requires data attribute");
+    async function findFirst(params = {}) {
+        const query$1 = await strapiUtils.async.pipe(validateParams, draftAndPublish.defaultToDraft, draftAndPublish.statusToLookup(contentType), internationalization.defaultLocale(contentType), internationalization.localeToLookup(contentType), idTransform.transformParamsDocumentId(uid), query.transformParamsToQuery(uid))(params);
+        return strapi.db.query(uid).findOne(query$1);
     }
-    const validData = await index.validateEntityCreation(contentType, data2, {
-      // Note: publishedAt value will always be set when DP is disabled
-      isDraft: !params$1?.data?.publishedAt,
-      locale: params$1?.locale
-    });
-    const componentData = await components.createComponents(uid, validData);
-    const contentTypeWithoutComponentData = components.omitComponentData(contentType, validData);
-    const entryData = index$1.applyTransforms(
-      Object.assign(contentTypeWithoutComponentData, componentData),
-      { contentType }
-    );
-    const doc = await strapi.db.query(uid).create({ ...query, data: entryData });
-    return doc;
-  }
-  async function create(params2 = {}) {
-    const queryParams = await strapiUtils.async.pipe(
-      draftAndPublish.filterDataPublishedAt,
-      draftAndPublish.setStatusToDraft(contentType),
-      draftAndPublish.statusToData(contentType),
-      internationalization.defaultLocale(contentType),
-      internationalization.localeToData(contentType)
-    )(params2);
-    const doc = await createEntry(queryParams);
-    if (hasDraftAndPublish && params2.status === "published") {
-      return publish(doc.documentId, params2).then((doc2) => doc2.versions[0]);
+    // TODO: do we really want to add filters on the findOne now that we have findFirst ?
+    async function findOne(opts = {}) {
+        const { documentId, ...params } = opts;
+        const query$1 = await strapiUtils.async.pipe(validateParams, draftAndPublish.defaultToDraft, draftAndPublish.statusToLookup(contentType), internationalization.defaultLocale(contentType), internationalization.localeToLookup(contentType), idTransform.transformParamsDocumentId(uid), query.transformParamsToQuery(uid), (query)=>fp.assoc('where', {
+                ...query.where,
+                documentId
+            }, query))(params);
+        return strapi.db.query(uid).findOne(query$1);
     }
-    return doc;
-  }
-  async function clone(documentId, params2 = {}) {
-    const queryParams = await strapiUtils.async.pipe(
-      draftAndPublish.filterDataPublishedAt,
-      internationalization.defaultLocale(contentType),
-      internationalization.multiLocaleToLookup(contentType)
-    )(params2);
-    const entriesToClone = await strapi.db?.query(uid).findMany({
-      where: {
-        ...queryParams?.lookup,
-        documentId,
-        // DP Enabled: Clone drafts
-        // DP Disabled: Clone only the existing version (published)
-        publishedAt: { $null: hasDraftAndPublish }
-      },
-      populate: populate.getDeepPopulate(uid, { relationalFields: ["id"] })
-    });
-    const clonedEntries = await strapiUtils.async.map(
-      entriesToClone,
-      strapiUtils.async.pipe(
-        _.omit("id"),
-        // assign new documentId
-        _.assoc("documentId", transformContentTypesToModels.createDocumentId()),
-        // Merge new data into it
-        (data2) => _.merge(data2, queryParams.data),
-        (data2) => createEntry({ ...queryParams, data: data2, status: "draft" })
-      )
-    );
-    return { documentId: clonedEntries.at(0)?.documentId, versions: clonedEntries };
-  }
-  async function update(documentId, params$1 = {}) {
-    const queryParams = await strapiUtils.async.pipe(
-      draftAndPublish.filterDataPublishedAt,
-      draftAndPublish.setStatusToDraft(contentType),
-      draftAndPublish.statusToLookup(contentType),
-      draftAndPublish.statusToData(contentType),
-      // Default locale will be set if not provided
-      internationalization.defaultLocale(contentType),
-      internationalization.localeToLookup(contentType),
-      internationalization.localeToData(contentType)
-    )(params$1);
-    const { data: data2, ...restParams } = await idTransform.transformParamsDocumentId(uid, queryParams || {});
-    const query = transformParamsToQuery(uid, params.pickSelectionParams(restParams || {}));
-    const model = strapi.contentType(uid);
-    const entryToUpdate = await strapi.db.query(uid).findOne({ ...query, where: { ...queryParams?.lookup, ...query?.where, documentId } });
-    let updatedDraft = null;
-    if (entryToUpdate) {
-      const validData = await index.validateEntityUpdate(
-        model,
-        // @ts-expect-error we need type guard to assert that data has the valid type
-        data2,
-        {
-          isDraft: !queryParams?.data?.publishedAt,
-          // Always update the draft version
-          locale: queryParams?.locale
-        },
-        entryToUpdate
-      );
-      const componentData = await components.updateComponents(uid, entryToUpdate, validData);
-      const entryData = index$1.applyTransforms(
-        Object.assign(components.omitComponentData(model, validData), componentData),
-        { contentType: model }
-      );
-      updatedDraft = await strapi.db.query(uid).update({ ...query, where: { id: entryToUpdate.id }, data: entryData });
+    async function deleteDocument(opts = {}) {
+        const { documentId, ...params } = opts;
+        const query$1 = await strapiUtils.async.pipe(validateParams, fp.omit('status'), internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType), query.transformParamsToQuery(uid), (query)=>fp.assoc('where', {
+                ...query.where,
+                documentId
+            }, query))(params);
+        if (params.status === 'draft') {
+            throw new Error('Cannot delete a draft document');
+        }
+        const entriesToDelete = await strapi.db.query(uid).findMany(query$1);
+        // Delete all matched entries and its components
+        const deletedEntries = await strapiUtils.async.map(entriesToDelete, (entryToDelete)=>entries$1.delete(entryToDelete.id));
+        entriesToDelete.forEach(emitEvent('entry.delete'));
+        return {
+            documentId,
+            entries: deletedEntries
+        };
     }
-    if (!updatedDraft) {
-      const documentExists = await strapi.db.query(contentType.uid).findOne({ where: { documentId } });
-      if (documentExists) {
-        updatedDraft = await createEntry({
-          ...queryParams,
-          data: { ...queryParams.data, documentId }
+    async function create(opts = {}) {
+        const { documentId, ...params } = opts;
+        const queryParams = await strapiUtils.async.pipe(validateParams, draftAndPublish.filterDataPublishedAt, draftAndPublish.setStatusToDraft(contentType), draftAndPublish.statusToData(contentType), internationalization.defaultLocale(contentType), internationalization.localeToData(contentType))(params);
+        const doc = await entries$1.create(queryParams);
+        emitEvent('entry.create', doc);
+        if (hasDraftAndPublish && params.status === 'published') {
+            return publish({
+                ...params,
+                documentId: doc.documentId
+            }).then((doc)=>doc.entries[0]);
+        }
+        return doc;
+    }
+    async function clone(opts = {}) {
+        const { documentId, ...params } = opts;
+        const queryParams = await strapiUtils.async.pipe(validateParams, draftAndPublish.filterDataPublishedAt, internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType))(params);
+        // Get deep populate
+        const entriesToClone = await strapi.db.query(uid).findMany({
+            where: {
+                ...queryParams?.lookup,
+                documentId,
+                // DP Enabled: Clone drafts
+                // DP Disabled: Clone only the existing version (published)
+                publishedAt: {
+                    $null: hasDraftAndPublish
+                }
+            },
+            populate: populate.getDeepPopulate(uid, {
+                relationalFields: [
+                    'id'
+                ]
+            })
+        });
+        const clonedEntries = await strapiUtils.async.map(entriesToClone, strapiUtils.async.pipe(validateParams, fp.omit([
+            'id',
+            'createdAt',
+            'updatedAt'
+        ]), // assign new documentId
+        fp.assoc('documentId', transformContentTypesToModels.createDocumentId()), // Merge new data into it
+        (data)=>fp.merge(data, queryParams.data), (data)=>entries$1.create({
+                ...queryParams,
+                data,
+                status: 'draft'
+            })));
+        clonedEntries.forEach(emitEvent('entry.create'));
+        return {
+            documentId: clonedEntries.at(0)?.documentId,
+            entries: clonedEntries
+        };
+    }
+    async function update(opts = {}) {
+        const { documentId, ...params$1 } = opts;
+        const queryParams = await strapiUtils.async.pipe(validateParams, draftAndPublish.filterDataPublishedAt, firstPublishedAt.filterDataFirstPublishedAt, draftAndPublish.setStatusToDraft(contentType), draftAndPublish.statusToLookup(contentType), draftAndPublish.statusToData(contentType), // Default locale will be set if not provided
+        internationalization.defaultLocale(contentType), internationalization.localeToLookup(contentType), internationalization.localeToData(contentType))(params$1);
+        const { data, ...restParams } = await idTransform.transformParamsDocumentId(uid, queryParams || {});
+        const query$1 = query.transformParamsToQuery(uid, params.pickSelectionParams(restParams || {}));
+        // Validation
+        // Find if document exists
+        const entryToUpdate = await strapi.db.query(uid).findOne({
+            ...query$1,
+            where: {
+                ...queryParams?.lookup,
+                ...query$1?.where,
+                documentId
+            }
+        });
+        let updatedDraft = null;
+        if (entryToUpdate) {
+            updatedDraft = await entries$1.update(entryToUpdate, queryParams);
+            emitEvent('entry.update', updatedDraft);
+        }
+        if (!updatedDraft) {
+            const documentExists = await strapi.db.query(contentType.uid).findOne({
+                where: {
+                    documentId
+                }
+            });
+            if (documentExists) {
+                const mergedData = await internationalization.copyNonLocalizedFields(contentType, documentId, {
+                    ...queryParams.data,
+                    documentId
+                });
+                updatedDraft = await entries$1.create({
+                    ...queryParams,
+                    data: mergedData
+                });
+                emitEvent('entry.create', updatedDraft);
+            }
+        }
+        if (hasDraftAndPublish && updatedDraft && params$1.status === 'published') {
+            return publish({
+                ...params$1,
+                documentId
+            }).then((doc)=>doc.entries[0]);
+        }
+        return updatedDraft;
+    }
+    async function count(params = {}) {
+        const query$1 = await strapiUtils.async.pipe(validateParams, draftAndPublish.defaultStatus(contentType), draftAndPublish.statusToLookup(contentType), internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType), query.transformParamsToQuery(uid))(params);
+        return strapi.db.query(uid).count(query$1);
+    }
+    async function publish(opts = {}) {
+        const { documentId, ...params } = opts;
+        const queryParams = await strapiUtils.async.pipe(validateParams, internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType))(params);
+        const [draftsToPublish, oldPublishedVersions] = await Promise.all([
+            strapi.db.query(uid).findMany({
+                where: {
+                    ...queryParams?.lookup,
+                    documentId,
+                    publishedAt: null
+                },
+                // Populate relations, media, compos and dz
+                populate: populate.getDeepPopulate(uid, {
+                    relationalFields: [
+                        'documentId',
+                        'locale'
+                    ]
+                })
+            }),
+            strapi.db.query(uid).findMany({
+                where: {
+                    ...queryParams?.lookup,
+                    documentId,
+                    publishedAt: {
+                        $ne: null
+                    }
+                },
+                select: [
+                    'id',
+                    'locale'
+                ]
+            })
+        ]);
+        // Load any unidirectional relation targetting the old published entries
+        const relationsToSync = await unidirectionalRelations.load(uid, {
+            newVersions: draftsToPublish,
+            oldVersions: oldPublishedVersions
+        }, {
+            shouldPropagateRelation: components.createComponentRelationFilter()
         });
-      }
+        const bidirectionalRelationsToSync = await bidirectionalRelations.load(uid, {
+            newVersions: draftsToPublish,
+            oldVersions: oldPublishedVersions
+        });
+        // Delete old published versions
+        await strapiUtils.async.map(oldPublishedVersions, (entry)=>entries$1.delete(entry.id));
+        // Add firstPublishedAt to draft if it doesn't exist
+        const updatedDraft = await strapiUtils.async.map(draftsToPublish, (draft)=>firstPublishedAt.addFirstPublishedAtToDraft(draft, entries$1.update, contentType));
+        // Transform draft entry data and create published versions
+        const publishedEntries = await strapiUtils.async.map(updatedDraft, (draft)=>entries$1.publish(draft, queryParams));
+        // Sync unidirectional relations with the new published entries
+        await unidirectionalRelations.sync([
+            ...oldPublishedVersions,
+            ...updatedDraft
+        ], publishedEntries, relationsToSync);
+        await bidirectionalRelations.sync([
+            ...oldPublishedVersions,
+            ...updatedDraft
+        ], publishedEntries, bidirectionalRelationsToSync);
+        publishedEntries.forEach(emitEvent('entry.publish'));
+        return {
+            documentId,
+            entries: publishedEntries
+        };
+    }
+    async function unpublish(opts = {}) {
+        const { documentId, ...params } = opts;
+        const query$1 = await strapiUtils.async.pipe(validateParams, internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType), query.transformParamsToQuery(uid), (query)=>fp.assoc('where', {
+                ...query.where,
+                documentId,
+                publishedAt: {
+                    $ne: null
+                }
+            }, query))(params);
+        // Delete all published versions
+        const versionsToDelete = await strapi.db.query(uid).findMany(query$1);
+        await strapiUtils.async.map(versionsToDelete, (entry)=>entries$1.delete(entry.id));
+        versionsToDelete.forEach(emitEvent('entry.unpublish'));
+        return {
+            documentId,
+            entries: versionsToDelete
+        };
+    }
+    async function discardDraft(opts = {}) {
+        const { documentId, ...params } = opts;
+        const queryParams = await strapiUtils.async.pipe(validateParams, internationalization.defaultLocale(contentType), internationalization.multiLocaleToLookup(contentType))(params);
+        const [versionsToDraft, oldDrafts] = await Promise.all([
+            strapi.db.query(uid).findMany({
+                where: {
+                    ...queryParams?.lookup,
+                    documentId,
+                    publishedAt: {
+                        $ne: null
+                    }
+                },
+                // Populate relations, media, compos and dz
+                populate: populate.getDeepPopulate(uid, {
+                    relationalFields: [
+                        'documentId',
+                        'locale'
+                    ]
+                })
+            }),
+            strapi.db.query(uid).findMany({
+                where: {
+                    ...queryParams?.lookup,
+                    documentId,
+                    publishedAt: null
+                },
+                select: [
+                    'id',
+                    'locale'
+                ]
+            })
+        ]);
+        // Load any unidirectional relation targeting the old drafts
+        const relationsToSync = await unidirectionalRelations.load(uid, {
+            newVersions: versionsToDraft,
+            oldVersions: oldDrafts
+        }, {
+            shouldPropagateRelation: components.createComponentRelationFilter()
+        });
+        const bidirectionalRelationsToSync = await bidirectionalRelations.load(uid, {
+            newVersions: versionsToDraft,
+            oldVersions: oldDrafts
+        });
+        // Delete old drafts
+        await strapiUtils.async.map(oldDrafts, (entry)=>entries$1.delete(entry.id));
+        // Transform published entry data and create draft versions
+        const draftEntries = await strapiUtils.async.map(versionsToDraft, (entry)=>entries$1.discardDraft(entry, queryParams));
+        // Sync unidirectional relations with the new draft entries
+        await unidirectionalRelations.sync([
+            ...oldDrafts,
+            ...versionsToDraft
+        ], draftEntries, relationsToSync);
+        await bidirectionalRelations.sync([
+            ...oldDrafts,
+            ...versionsToDraft
+        ], draftEntries, bidirectionalRelationsToSync);
+        draftEntries.forEach(emitEvent('entry.draft-discard'));
+        return {
+            documentId,
+            entries: draftEntries
+        };
+    }
+    async function updateComponents(entry, data) {
+        return components.updateComponents(uid, entry, data);
     }
-    if (hasDraftAndPublish && updatedDraft && params$1.status === "published") {
-      return publish(documentId, params$1).then((doc) => doc.versions[0]);
+    function omitComponentData(data) {
+        return components.omitComponentData(contentType, data);
     }
-    return updatedDraft;
-  }
-  async function count(params2 = {}) {
-    const query = await strapiUtils.async.pipe(
-      draftAndPublish.defaultStatus(contentType),
-      draftAndPublish.statusToLookup(contentType),
-      internationalization.defaultLocale(contentType),
-      internationalization.localeToLookup(contentType),
-      transformParamsToQuery(uid)
-    )(params2);
-    return strapi.db.query(uid).count(query);
-  }
-  async function publish(documentId, params2 = {}) {
-    const queryParams = await strapiUtils.async.pipe(
-      internationalization.defaultLocale(contentType),
-      internationalization.multiLocaleToLookup(contentType)
-    )(params2);
-    await deleteFn(documentId, {
-      ...queryParams,
-      lookup: { ...queryParams?.lookup, publishedAt: { $ne: null } }
-    });
-    const entriesToPublish = await strapi.db?.query(uid).findMany({
-      where: {
-        ...queryParams?.lookup,
-        documentId,
-        publishedAt: null
-      },
-      populate: populate.getDeepPopulate(uid, { relationalFields: ["documentId", "locale"] })
-    });
-    const publishedEntries = await strapiUtils.async.map(
-      entriesToPublish,
-      strapiUtils.async.pipe(
-        // Updated at value is used to know if draft has been modified
-        // If both versions share the same value, it means the draft has not been modified
-        (draft) => _.assoc("updatedAt", draft.updatedAt, draft),
-        _.assoc("publishedAt", /* @__PURE__ */ new Date()),
-        _.assoc("documentId", documentId),
-        _.omit("id"),
-        // Transform relations to target published versions
-        (entry) => {
-          const opts = { uid, locale: entry.locale, status: "published", allowMissingId: true };
-          return data.transformData(entry, opts);
-        },
-        // Create the published entry
-        (data2) => createEntry({ ...queryParams, data: data2, locale: data2.locale, status: "published" })
-      )
-    );
-    return { versions: publishedEntries };
-  }
-  async function unpublish(documentId, params2 = {}) {
-    const queryParams = await strapiUtils.async.pipe(
-      internationalization.defaultLocale(contentType),
-      internationalization.multiLocaleToLookup(contentType)
-    )(params2);
-    const { deletedEntries } = await deleteFn(documentId, {
-      ...params2,
-      lookup: { ...queryParams?.lookup, publishedAt: { $ne: null } }
-    });
-    return { versions: deletedEntries };
-  }
-  async function discardDraft(documentId, params2 = {}) {
-    const queryParams = await strapiUtils.async.pipe(
-      internationalization.defaultLocale(contentType),
-      internationalization.multiLocaleToLookup(contentType)
-    )(params2);
-    await deleteFn(documentId, {
-      ...queryParams,
-      // Delete all drafts that match query
-      lookup: { ...queryParams?.lookup, publishedAt: null }
-    });
-    const entriesToDraft = await strapi.db?.query(uid).findMany({
-      where: {
-        ...queryParams?.lookup,
-        documentId,
-        publishedAt: { $ne: null }
-      },
-      populate: populate.getDeepPopulate(uid, { relationalFields: ["documentId", "locale"] })
-    });
-    const draftEntries = await strapiUtils.async.map(
-      entriesToDraft,
-      strapiUtils.async.pipe(
-        _.assoc("publishedAt", null),
-        _.assoc("documentId", documentId),
-        _.omit("id"),
-        // Transform relations to target draft versions
-        (entry) => {
-          const opts = { uid, locale: entry.locale, status: "draft", allowMissingId: true };
-          return data.transformData(entry, opts);
-        },
-        // Create the draft entry
-        (data2) => createEntry({ ...queryParams, locale: data2.locale, data: data2, status: "draft" })
-      )
-    );
-    return { versions: draftEntries };
-  }
-  return {
-    findMany: common.wrapInTransaction(findMany),
-    findFirst: common.wrapInTransaction(findFirst),
-    findOne: common.wrapInTransaction(findOne),
-    delete: common.wrapInTransaction(deleteFn),
-    create: common.wrapInTransaction(create),
-    clone: common.wrapInTransaction(clone),
-    update: common.wrapInTransaction(update),
-    count: common.wrapInTransaction(count),
-    publish: hasDraftAndPublish ? common.wrapInTransaction(publish) : void 0,
-    unpublish: hasDraftAndPublish ? common.wrapInTransaction(unpublish) : void 0,
-    discardDraft: hasDraftAndPublish ? common.wrapInTransaction(discardDraft) : void 0
-  };
+    return {
+        findMany: common.wrapInTransaction(findMany),
+        findFirst: common.wrapInTransaction(findFirst),
+        findOne: common.wrapInTransaction(findOne),
+        delete: common.wrapInTransaction(deleteDocument),
+        create: common.wrapInTransaction(create),
+        clone: common.wrapInTransaction(clone),
+        update: common.wrapInTransaction(update),
+        count: common.wrapInTransaction(count),
+        publish: hasDraftAndPublish ? common.wrapInTransaction(publish) : undefined,
+        unpublish: hasDraftAndPublish ? common.wrapInTransaction(unpublish) : undefined,
+        discardDraft: hasDraftAndPublish ? common.wrapInTransaction(discardDraft) : undefined,
+        updateComponents,
+        omitComponentData
+    };
 };
+
 exports.createContentTypeRepository = createContentTypeRepository;
 //# sourceMappingURL=repository.js.map