@strapi/content-manager 0.0.0-next.c9f32f6f0c2be1b88323373117f12eb33219d20e → 0.0.0-next.cb666fde52df857549ddd0e7bf1f6888f5d06951

package/dist/server/index.js

@@ -10,8 +10,7 @@ const qs = require("qs");
 const slugify = require("@sindresorhus/slugify");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
-  if (e && e.__esModule)
-    return e;
+  if (e && e.__esModule) return e;
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
     for (const k in e) {
@@ -167,8 +166,7 @@ const createServiceUtils = ({ strapi: strapi2 }) => {
   };
   const getRelationRestoreValue = async (versionRelationData, attribute) => {
     if (Array.isArray(versionRelationData)) {
-      if (versionRelationData.length === 0)
-        return versionRelationData;
+      if (versionRelationData.length === 0) return versionRelationData;
       const existingAndMissingRelations = await Promise.all(
         versionRelationData.map((relation) => {
           return strapi2.documents(attribute.target).findOne({
@@ -177,19 +175,16 @@ const createServiceUtils = ({ strapi: strapi2 }) => {
           });
         })
       );
-      return existingAndMissingRelations.filter(
-        (relation) => relation !== null
-      );
+      return existingAndMissingRelations.filter((relation) => relation !== null);
     }
     return strapi2.documents(attribute.target).findOne({
       documentId: versionRelationData.documentId,
       locale: versionRelationData.locale || void 0
     });
   };
-  const getMediaRestoreValue = async (versionRelationData, attribute) => {
-    if (attribute.multiple) {
+  const getMediaRestoreValue = async (versionRelationData) => {
+    if (Array.isArray(versionRelationData)) {
       const existingAndMissingMedias = await Promise.all(
-        // @ts-expect-error Fix the type definitions so this isn't any
         versionRelationData.map((media) => {
           return strapi2.db.query("plugin::upload.file").findOne({ where: { id: media.id } });
         })
@@ -203,8 +198,7 @@ const createServiceUtils = ({ strapi: strapi2 }) => {
   const getDefaultLocale = async () => localesService ? localesService.getDefaultLocale() : null;
   const isLocalizedContentType = (model) => i18nContentTypeService ? i18nContentTypeService.isLocalizedContentType(model) : false;
   const getLocaleDictionary = async () => {
-    if (!localesService)
-      return {};
+    if (!localesService) return {};
     const locales = await localesService.find() || [];
     return locales.reduce(
       (acc, locale) => {
@@ -359,8 +353,8 @@ const createHistoryService = ({ strapi: strapi2 }) => {
       });
     },
     async findVersionsPage(params) {
-      const model = strapi2.getModel(params.query.contentType);
-      const isLocalizedContentType = serviceUtils.isLocalizedContentType(model);
+      const schema = strapi2.getModel(params.query.contentType);
+      const isLocalizedContentType = serviceUtils.isLocalizedContentType(schema);
       const defaultLocale = await serviceUtils.getDefaultLocale();
       let locale = null;
       if (isLocalizedContentType) {
@@ -381,32 +375,20 @@ const createHistoryService = ({ strapi: strapi2 }) => {
         }),
         serviceUtils.getLocaleDictionary()
       ]);
-      const populateEntryRelations = async (entry) => {
-        const entryWithRelations = await Object.entries(entry.schema).reduce(
-          async (currentDataWithRelations, [attributeKey, attributeSchema]) => {
-            const attributeValue = entry.data[attributeKey];
-            const attributeValues = Array.isArray(attributeValue) ? attributeValue : [attributeValue];
-            if (attributeSchema.type === "media") {
-              const permissionChecker2 = getService$2("permission-checker").create({
-                userAbility: params.state.userAbility,
-                model: "plugin::upload.file"
-              });
-              const response = await serviceUtils.buildMediaResponse(attributeValues);
-              const sanitizedResults = await Promise.all(
-                response.results.map((media) => permissionChecker2.sanitizeOutput(media))
-              );
-              return {
-                ...await currentDataWithRelations,
-                [attributeKey]: {
-                  results: sanitizedResults,
-                  meta: response.meta
-                }
-              };
+      const populateEntry = async (entry) => {
+        return strapiUtils.traverseEntity(
+          async (options, utils) => {
+            if (!options.attribute) return;
+            if (!options.value) return;
+            const currentValue = Array.isArray(options.value) ? options.value : [options.value];
+            if (options.attribute.type === "component") {
+              utils.remove("id");
             }
-            if (attributeSchema.type === "relation" && attributeSchema.relation !== "morphToOne" && attributeSchema.relation !== "morphToMany") {
-              if (attributeSchema.target === "admin::user") {
+            if (options.attribute.type === "relation" && // TODO: handle polymorphic relations
+            options.attribute.relation !== "morphToOne" && options.attribute.relation !== "morphToMany") {
+              if (options.attribute.target === "admin::user") {
                 const adminUsers = await Promise.all(
-                  attributeValues.map((userToPopulate) => {
+                  currentValue.map((userToPopulate) => {
                     if (userToPopulate == null) {
                       return null;
                     }
@@ -418,46 +400,51 @@ const createHistoryService = ({ strapi: strapi2 }) => {
                     });
                   })
                 );
-                return {
-                  ...await currentDataWithRelations,
-                  /**
-                   * Ideally we would return the same "{results: [], meta: {}}" shape, however,
-                   * when sanitizing the data as a whole in the controller before sending to the client,
-                   * the data for admin relation user is completely sanitized if we return an object here as opposed to an array.
-                   */
-                  [attributeKey]: adminUsers
-                };
+                utils.set(options.key, adminUsers);
               }
               const permissionChecker2 = getService$2("permission-checker").create({
                 userAbility: params.state.userAbility,
-                model: attributeSchema.target
+                model: options.attribute.target
               });
               const response = await serviceUtils.buildRelationReponse(
-                attributeValues,
-                attributeSchema
+                currentValue,
+                options.attribute
               );
               const sanitizedResults = await Promise.all(
                 response.results.map((media) => permissionChecker2.sanitizeOutput(media))
               );
-              return {
-                ...await currentDataWithRelations,
-                [attributeKey]: {
-                  results: sanitizedResults,
-                  meta: response.meta
-                }
-              };
+              utils.set(options.key, {
+                results: sanitizedResults,
+                meta: response.meta
+              });
+            }
+            if (options.attribute.type === "media") {
+              const permissionChecker2 = getService$2("permission-checker").create({
+                userAbility: params.state.userAbility,
+                model: "plugin::upload.file"
+              });
+              const response = await serviceUtils.buildMediaResponse(currentValue);
+              const sanitizedResults = await Promise.all(
+                response.results.map((media) => permissionChecker2.sanitizeOutput(media))
+              );
+              utils.set(options.key, {
+                results: sanitizedResults,
+                meta: response.meta
+              });
             }
-            return currentDataWithRelations;
           },
-          Promise.resolve(entry.data)
+          {
+            schema,
+            getModel: strapi2.getModel.bind(strapi2)
+          },
+          entry.data
         );
-        return entryWithRelations;
       };
       const formattedResults = await Promise.all(
         results.map(async (result) => {
           return {
             ...result,
-            data: await populateEntryRelations(result),
+            data: await populateEntry(result),
             meta: {
               unknownAttributes: serviceUtils.getSchemaAttributesDiff(
                 result.schema,
@@ -488,30 +475,44 @@ const createHistoryService = ({ strapi: strapi2 }) => {
         // Clone to avoid mutating the original version data
         structuredClone(version.data)
       );
-      const sanitizedSchemaAttributes = fp.omit(
-        FIELDS_TO_IGNORE,
-        contentTypeSchemaAttributes
-      );
-      const reducer = strapiUtils.async.reduce(Object.entries(sanitizedSchemaAttributes));
-      const dataWithoutMissingRelations = await reducer(
-        async (previousRelationAttributes, [name, attribute]) => {
-          const versionRelationData = version.data[name];
-          if (!versionRelationData) {
-            return previousRelationAttributes;
+      const schema = structuredClone(version.schema);
+      schema.attributes = fp.omit(FIELDS_TO_IGNORE, contentTypeSchemaAttributes);
+      const dataWithoutMissingRelations = await strapiUtils.traverseEntity(
+        async (options, utils) => {
+          if (!options.attribute) return;
+          if (options.attribute.type === "component") {
+            utils.remove("id");
+            if (options.attribute.repeatable && options.value === null) {
+              utils.set(options.key, []);
+            }
           }
-          if (attribute.type === "relation" && // TODO: handle polymorphic relations
-          attribute.relation !== "morphToOne" && attribute.relation !== "morphToMany") {
-            const data2 = await serviceUtils.getRelationRestoreValue(versionRelationData, attribute);
-            previousRelationAttributes[name] = data2;
+          if (options.attribute.type === "dynamiczone") {
+            if (options.value === null) {
+              utils.set(options.key, []);
+            }
           }
-          if (attribute.type === "media") {
-            const data2 = await serviceUtils.getMediaRestoreValue(versionRelationData, attribute);
-            previousRelationAttributes[name] = data2;
+          if (options.attribute.type === "relation" && // TODO: handle polymorphic relations
+          options.attribute.relation !== "morphToOne" && options.attribute.relation !== "morphToMany") {
+            if (!options.value) return;
+            const data2 = await serviceUtils.getRelationRestoreValue(
+              options.value,
+              options.attribute
+            );
+            utils.set(options.key, data2);
+          }
+          if (options.attribute.type === "media") {
+            if (!options.value) return;
+            const data2 = await serviceUtils.getMediaRestoreValue(
+              options.value
+            );
+            utils.set(options.key, data2);
           }
-          return previousRelationAttributes;
         },
-        // Clone to avoid mutating the original version data
-        structuredClone(dataWithoutAddedAttributes)
+        {
+          schema,
+          getModel: strapi2.getModel.bind(strapi2)
+        },
+        dataWithoutAddedAttributes
       );
       const data = fp.omit(["id", ...Object.keys(schemaDiff.removed)], dataWithoutMissingRelations);
       const restoredDocument = await strapi2.documents(version.contentType).update({
@@ -740,7 +741,6 @@ const getFeature$1 = () => {
   };
 };
 const history = getFeature$1();
-const FEATURE_ID = "preview";
 const info = { pluginName: "content-manager", type: "admin" };
 const previewRouter = {
   type: "admin",
@@ -918,9 +918,6 @@ const services$1 = {
   "preview-config": createPreviewConfigService
 };
 const getFeature = () => {
-  if (!strapi.features.future.isEnabled(FEATURE_ID)) {
-    return {};
-  }
   return {
     register() {
       const config = getService(strapi, "preview-config");
@@ -1506,8 +1503,7 @@ const isSortable = (schema, name) => {
   if (!___default.default.has(schema.attributes, name)) {
     return false;
   }
-  if (schema.modelType === "component" && name === "id")
-    return false;
+  if (schema.modelType === "component" && name === "id") return false;
   const attribute = schema.attributes[name];
   if (NON_SORTABLES.includes(attribute.type)) {
     return false;
@@ -1652,8 +1648,7 @@ const createDefaultSettings = async (schema) => {
   };
 };
 const syncSettings = async (configuration, schema) => {
-  if (fp.isEmpty(configuration.settings))
-    return createDefaultSettings(schema);
+  if (fp.isEmpty(configuration.settings)) return createDefaultSettings(schema);
   const defaultField = getDefaultMainField(schema);
   const { mainField = defaultField, defaultSortBy = defaultField } = configuration.settings || {};
   return {
@@ -1829,8 +1824,7 @@ const excludeNotCreatableFields = (uid2, permissionChecker2) => (body, path = []
     }
     switch (attribute.type) {
       case "relation": {
-        if (canCreate(attributePath))
-          return body2;
+        if (canCreate(attributePath)) return body2;
         return fp.set(attributePath, { set: [] }, body2);
       }
       case "component": {
@@ -1840,8 +1834,7 @@ const excludeNotCreatableFields = (uid2, permissionChecker2) => (body, path = []
         ]);
       }
       default: {
-        if (canCreate(attributePath))
-          return body2;
+        if (canCreate(attributePath)) return body2;
         return fp.set(attributePath, null, body2);
       }
     }
@@ -2634,8 +2627,7 @@ const validateStatus = (sourceUid, status) => {
   const sourceModel = strapi.getModel(sourceUid);
   const isDP = strapiUtils.contentTypes.hasDraftAndPublish;
   const isSourceDP = isDP(sourceModel);
-  if (!isSourceDP)
-    return { status: void 0 };
+  if (!isSourceDP) return { status: void 0 };
   switch (status) {
     case "published":
       return { status: "published" };
@@ -3280,18 +3272,15 @@ async function syncMetadatas(configuration, schema) {
       ___default.default.set(updatedMeta, ["list", "searchable"], false);
       ___default.default.set(acc, [key], updatedMeta);
     }
-    if (!___default.default.has(edit, "mainField"))
-      return acc;
+    if (!___default.default.has(edit, "mainField")) return acc;
     if (!isRelation$1(attr)) {
       ___default.default.set(updatedMeta, "edit", ___default.default.omit(edit, ["mainField"]));
       ___default.default.set(acc, [key], updatedMeta);
       return acc;
     }
-    if (edit.mainField === "id")
-      return acc;
+    if (edit.mainField === "id") return acc;
     const targetSchema = getTargetSchema(attr.targetModel);
-    if (!targetSchema)
-      return acc;
+    if (!targetSchema) return acc;
     if (!isSortable(targetSchema, edit.mainField) && !isListable(targetSchema, edit.mainField)) {
       ___default.default.set(updatedMeta, ["edit", "mainField"], getDefaultMainField(targetSchema));
       ___default.default.set(acc, [key], updatedMeta);
@@ -3336,8 +3325,7 @@ function createDefaultEditLayout(schema) {
   return appendToEditLayout([], keys2, schema);
 }
 function syncLayouts(configuration, schema) {
-  if (___default.default.isEmpty(configuration.layouts))
-    return createDefaultLayouts(schema);
+  if (___default.default.isEmpty(configuration.layouts)) return createDefaultLayouts(schema);
   const { list = [], editRelations = [], edit = [] } = configuration.layouts || {};
   let cleanList = list.filter((attr) => isListable(schema, attr));
   const cleanEditRelations = editRelations.filter(
@@ -3348,8 +3336,7 @@ function syncLayouts(configuration, schema) {
   for (const row of edit) {
     const newRow = [];
     for (const el of row) {
-      if (!hasEditableAttribute(schema, el.name))
-        continue;
+      if (!hasEditableAttribute(schema, el.name)) continue;
       const { hasFieldSize } = getService$2("field-sizes");
       const fieldType = hasFieldSize(schema.attributes[el.name].customField) ? schema.attributes[el.name].customField : schema.attributes[el.name].type;
       if (!isAllowedFieldSize(fieldType, el.size)) {
@@ -3380,8 +3367,7 @@ function syncLayouts(configuration, schema) {
   };
 }
 const appendToEditLayout = (layout = [], keysToAppend, schema) => {
-  if (keysToAppend.length === 0)
-    return layout;
+  if (keysToAppend.length === 0) return layout;
   let currentRowIndex = Math.max(layout.length - 1, 0);
   if (!layout[currentRowIndex]) {
     layout[currentRowIndex] = [];
@@ -3947,6 +3933,12 @@ function getPopulateForRelation(attribute, model, attributeName, { countMany, co
   if (initialPopulate) {
     return initialPopulate;
   }
+  if (attributeName === "localizations") {
+    const validationPopulate = getPopulateForValidation(model.uid);
+    return {
+      populate: validationPopulate.populate
+    };
+  }
   if (!isVisibleAttribute$1(model, attributeName)) {
     return true;
   }
@@ -4006,6 +3998,9 @@ const getDeepPopulate = (uid2, {
     return {};
   }
   const model = strapi.getModel(uid2);
+  if (!model) {
+    return {};
+  }
   return Object.keys(model.attributes).reduce(
     (populateAcc, attributeName) => fp.merge(
       populateAcc,
@@ -4025,40 +4020,46 @@ const getDeepPopulate = (uid2, {
     {}
   );
 };
-const getValidatableFieldsPopulate = (uid2, {
-  initialPopulate = {},
-  countMany = false,
-  countOne = false,
-  maxLevel = Infinity
-} = {}, level = 1) => {
-  if (level > maxLevel) {
+const getPopulateForValidation = (uid2) => {
+  const model = strapi.getModel(uid2);
+  if (!model) {
     return {};
   }
-  const model = strapi.getModel(uid2);
   return Object.entries(model.attributes).reduce((populateAcc, [attributeName, attribute]) => {
-    if (!getDoesAttributeRequireValidation(attribute)) {
+    if (isScalarAttribute(attribute)) {
+      if (getDoesAttributeRequireValidation(attribute)) {
+        populateAcc.fields = populateAcc.fields || [];
+        populateAcc.fields.push(attributeName);
+      }
       return populateAcc;
     }
-    if (isScalarAttribute(attribute)) {
-      return fp.merge(populateAcc, {
-        [attributeName]: true
-      });
+    if (isComponent(attribute)) {
+      const component = attribute.component;
+      const componentResult = getPopulateForValidation(component);
+      if (Object.keys(componentResult).length > 0) {
+        populateAcc.populate = populateAcc.populate || {};
+        populateAcc.populate[attributeName] = componentResult;
+      }
+      return populateAcc;
     }
-    return fp.merge(
-      populateAcc,
-      getPopulateFor(
-        attributeName,
-        model,
-        {
-          // @ts-expect-error - improve types
-          initialPopulate: initialPopulate?.[attributeName],
-          countMany,
-          countOne,
-          maxLevel
+    if (isDynamicZone(attribute)) {
+      const components2 = attribute.components;
+      const componentsResult = (components2 || []).reduce(
+        (acc, componentUID) => {
+          const componentResult = getPopulateForValidation(componentUID);
+          if (Object.keys(componentResult).length > 0) {
+            acc[componentUID] = componentResult;
+          }
+          return acc;
         },
-        level
-      )
-    );
+        {}
+      );
+      if (Object.keys(componentsResult).length > 0) {
+        populateAcc.populate = populateAcc.populate || {};
+        populateAcc.populate[attributeName] = { on: componentsResult };
+      }
+    }
+    return populateAcc;
   }, {});
 };
 const getDeepPopulateDraftCount = (uid2) => {
@@ -4300,7 +4301,6 @@ const AVAILABLE_LOCALES_FIELDS = [
   "locale",
   "updatedAt",
   "createdAt",
-  "status",
   "publishedAt",
   "documentId"
 ];
@@ -4321,36 +4321,20 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
   /**
    * Returns available locales of a document for the current status
    */
-  async getAvailableLocales(uid2, version, allVersions, validatableFields = []) {
+  async getAvailableLocales(uid2, version, allVersions) {
     const versionsByLocale = fp.groupBy("locale", allVersions);
     if (version.locale) {
       delete versionsByLocale[version.locale];
     }
     const model = strapi2.getModel(uid2);
-    const keysToKeep = [...AVAILABLE_LOCALES_FIELDS, ...validatableFields];
-    const traversalFunction = async (localeVersion) => strapiUtils.traverseEntity(
-      ({ key }, { remove }) => {
-        if (keysToKeep.includes(key)) {
-          return;
-        }
-        remove(key);
-      },
-      { schema: model, getModel: strapi2.getModel.bind(strapi2) },
-      // @ts-expect-error fix types DocumentVersion incompatible with Data
-      localeVersion
-    );
     const mappingResult = await strapiUtils.async.map(
       Object.values(versionsByLocale),
       async (localeVersions) => {
-        const mappedLocaleVersions = await strapiUtils.async.map(
-          localeVersions,
-          traversalFunction
-        );
         if (!strapiUtils.contentTypes.hasDraftAndPublish(model)) {
-          return mappedLocaleVersions[0];
+          return localeVersions[0];
         }
-        const draftVersion = mappedLocaleVersions.find((v) => v.publishedAt === null);
-        const otherVersions = mappedLocaleVersions.filter((v) => v.id !== draftVersion?.id);
+        const draftVersion = localeVersions.find((v) => v.publishedAt === null);
+        const otherVersions = localeVersions.filter((v) => v.id !== draftVersion?.id);
         if (!draftVersion) {
           return;
         }
@@ -4372,8 +4356,7 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
       const matchStatus = status === "published" ? v.publishedAt !== null : v.publishedAt === null;
       return matchLocale && matchStatus;
     });
-    if (!availableStatus)
-      return availableStatus;
+    if (!availableStatus) return availableStatus;
     return fp.pick(AVAILABLE_STATUS_FIELDS, availableStatus);
   },
   /**
@@ -4383,18 +4366,19 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
    * @returns
    */
   async getManyAvailableStatus(uid2, documents) {
-    if (!documents.length)
-      return [];
+    if (!documents.length) return [];
     const status = documents[0].publishedAt !== null ? "published" : "draft";
-    const locale = documents[0]?.locale;
-    const otherStatus = status === "published" ? "draft" : "published";
-    return strapi2.documents(uid2).findMany({
-      filters: {
-        documentId: { $in: documents.map((d) => d.documentId).filter(Boolean) }
-      },
-      status: otherStatus,
-      locale,
-      fields: ["documentId", "locale", "updatedAt", "createdAt", "publishedAt"]
+    const locales = documents.map((d) => d.locale).filter(Boolean);
+    const where = {
+      documentId: { $in: documents.map((d) => d.documentId).filter(Boolean) },
+      publishedAt: { $null: status === "published" }
+    };
+    if (locales.length) {
+      where.locale = { $in: locales };
+    }
+    return strapi2.query(uid2).findMany({
+      where,
+      select: ["id", "documentId", "locale", "updatedAt", "createdAt", "publishedAt"]
     });
   },
   getStatus(version, otherDocumentStatuses) {
@@ -4411,10 +4395,8 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
     } else if (otherVersion) {
       draftVersion = otherVersion;
     }
-    if (!draftVersion)
-      return CONTENT_MANAGER_STATUS.PUBLISHED;
-    if (!publishedVersion)
-      return CONTENT_MANAGER_STATUS.DRAFT;
+    if (!draftVersion) return CONTENT_MANAGER_STATUS.PUBLISHED;
+    if (!publishedVersion) return CONTENT_MANAGER_STATUS.DRAFT;
     const isDraftModified = getIsVersionLatestModification(draftVersion, publishedVersion);
     return isDraftModified ? CONTENT_MANAGER_STATUS.MODIFIED : CONTENT_MANAGER_STATUS.PUBLISHED;
   },
@@ -4422,11 +4404,9 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
   // We could refactor this so the locales are only loaded when they're
   // needed. e.g. in the bulk locale action modal.
   async getMetadata(uid2, version, { availableLocales = true, availableStatus = true } = {}) {
-    const populate = getValidatableFieldsPopulate(uid2);
-    const versions = await strapi2.db.query(uid2).findMany({
-      where: { documentId: version.documentId },
+    const { populate = {}, fields = [] } = getPopulateForValidation(uid2);
+    const params = {
       populate: {
-        // Populate only fields that require validation for bulk locale actions
         ...populate,
         // NOTE: creator fields are selected in this way to avoid exposing sensitive data
         createdBy: {
@@ -4435,9 +4415,15 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
         updatedBy: {
           select: ["id", "firstname", "lastname", "email"]
         }
+      },
+      fields: fp.uniq([...AVAILABLE_LOCALES_FIELDS, ...fields]),
+      filters: {
+        documentId: version.documentId
       }
-    });
-    const availableLocalesResult = availableLocales ? await this.getAvailableLocales(uid2, version, versions, Object.keys(populate)) : [];
+    };
+    const dbParams = strapi2.get("query-params").transform(uid2, params);
+    const versions = await strapi2.db.query(uid2).findMany(dbParams);
+    const availableLocalesResult = availableLocales ? await this.getAvailableLocales(uid2, version, versions) : [];
     const availableStatusResult = availableStatus ? this.getAvailableStatus(version, versions) : null;
     return {
       availableLocales: availableLocalesResult,
@@ -4464,6 +4450,16 @@ const documentMetadata = ({ strapi: strapi2 }) => ({
       opts.availableStatus = false;
     }
     const meta = await this.getMetadata(uid2, document, opts);
+    if (document.localizations) {
+      const otherStatus = await this.getManyAvailableStatus(uid2, document.localizations);
+      document.localizations = document.localizations.map((d) => {
+        const status = otherStatus.find((s) => s.documentId === d.documentId);
+        return {
+          ...d,
+          status: this.getStatus(d, status ? [status] : [])
+        };
+      });
+    }
     return {
       data: {
         ...document,