strapi-plugin-meilisearch 0.16.2 → 0.16.3

package/dist/server/index.js

@@ -322,88 +322,371 @@ const configurationService = ({ strapi: strapi2 }) => {
     }
   };
 };
-async function registerDocumentMiddleware({ strapi: strapi2 }) {
-  if (!strapi2?.documents || typeof strapi2.documents.use !== "function") {
-    return;
-  }
-  const extractEntryCandidates = (result) => {
-    if (result == null) return [];
-    const candidates = [];
-    const appendCandidate = (data, source) => {
-      if (data != null && typeof data === "object") {
-        candidates.push({ data, source });
-      }
-    };
-    if (Array.isArray(result)) {
-      result.forEach((data) => appendCandidate(data, "root"));
-      return candidates;
-    }
-    appendCandidate(result, "root");
-    if (Array.isArray(result.versions)) {
-      result.versions.forEach((data) => appendCandidate(data, "versions"));
-    }
-    if (Array.isArray(result.entries)) {
-      result.entries.forEach((data) => appendCandidate(data, "entries"));
+const resolveDocumentIdsFromActionParams = (actionParams) => {
+  const explicitDocumentIds = Array.isArray(actionParams?.documentIds) ? actionParams.documentIds.filter(
+    (documentId) => typeof documentId === "string" && documentId.length > 0
+  ) : [];
+  const singleDocumentId = typeof actionParams?.documentId === "string" && actionParams.documentId.length > 0 ? [actionParams.documentId] : [];
+  return [.../* @__PURE__ */ new Set([...explicitDocumentIds, ...singleDocumentId])];
+};
+const resolveDocumentIds = ({
+  actionParams,
+  result,
+  preActionSnapshots
+}) => {
+  const ids = [...resolveDocumentIdsFromActionParams(actionParams)];
+  const appendDocumentId = (documentId) => {
+    if (typeof documentId === "string" && documentId.length > 0) {
+      ids.push(documentId);
     }
-    if (result.entry != null) {
-      appendCandidate(result.entry, "entry");
+  };
+  const inspectCandidate = (candidate) => {
+    if (!candidate || typeof candidate !== "object") return;
+    appendDocumentId(candidate.documentId);
+  };
+  if (Array.isArray(result)) {
+    result.forEach(inspectCandidate);
+  } else {
+    inspectCandidate(result);
+  }
+  (preActionSnapshots || []).forEach(
+    (snapshot) => appendDocumentId(snapshot?.documentId)
+  );
+  return [...new Set(ids)];
+};
+const extractStrapiEntryCandidates = (result) => {
+  if (result == null) return [];
+  const candidates = [];
+  const appendCandidate = (data, source) => {
+    if (data != null && typeof data === "object") {
+      candidates.push({ data, source });
     }
-    return candidates;
   };
-  const isPublishedEntry = (entry) => !(entry?.publishedAt === void 0 || entry?.publishedAt === null);
-  const rankEntryCandidates = (candidates) => {
-    return [...candidates].sort((a, b) => {
-      const aHasPrimaryKey = a.data?.id != null;
-      const bHasPrimaryKey = b.data?.id != null;
-      if (aHasPrimaryKey && !bHasPrimaryKey) return -1;
-      if (!aHasPrimaryKey && bHasPrimaryKey) return 1;
-      const aIsRoot = a.source === "root";
-      const bIsRoot = b.source === "root";
-      if (!aIsRoot && bIsRoot) return -1;
-      if (aIsRoot && !bIsRoot) return 1;
-      return 0;
-    });
+  if (Array.isArray(result)) {
+    result.forEach((data) => appendCandidate(data, "root"));
+    return candidates;
+  }
+  appendCandidate(result, "root");
+  if (Array.isArray(result.versions)) {
+    result.versions.forEach((data) => appendCandidate(data, "versions"));
+  }
+  if (Array.isArray(result.entries)) {
+    result.entries.forEach((data) => appendCandidate(data, "entries"));
+  }
+  if (result.entry != null) {
+    appendCandidate(result.entry, "entry");
+  }
+  return candidates;
+};
+const isPublishedStrapiEntry = (entry) => !(entry?.publishedAt === void 0 || entry?.publishedAt === null);
+const rankStrapiEntryCandidates = (candidates) => {
+  return [...candidates].sort((a, b) => {
+    const aHasPrimaryKey = a.data?.id != null;
+    const bHasPrimaryKey = b.data?.id != null;
+    if (aHasPrimaryKey && !bHasPrimaryKey) return -1;
+    if (!aHasPrimaryKey && bHasPrimaryKey) return 1;
+    const aIsRoot = a.source === "root";
+    const bIsRoot = b.source === "root";
+    if (!aIsRoot && bIsRoot) return -1;
+    if (aIsRoot && !bIsRoot) return 1;
+    return 0;
+  });
+};
+const getActionLocale = (actionParams) => {
+  return typeof actionParams?.locale === "string" && actionParams.locale.length > 0 ? actionParams.locale : null;
+};
+const resolvePreferredConcreteLocale = ({ syncQuery, actionParams }) => {
+  const actionLocale = getActionLocale(actionParams);
+  if (actionLocale && !isWildcardLocale(actionLocale)) {
+    return actionLocale;
+  }
+  const syncLocale = typeof syncQuery?.locale === "string" && syncQuery.locale.length > 0 ? syncQuery.locale : null;
+  if (syncLocale && !isWildcardLocale(syncLocale)) {
+    return syncLocale;
+  }
+  return null;
+};
+const resolveLocaleScopedReadQuery = ({ syncQuery, actionParams }) => {
+  const actionLocale = getActionLocale(actionParams);
+  const baseQuery = { ...syncQuery || {} };
+  if (!isWildcardLocale(baseQuery.locale) || actionLocale == null) {
+    return baseQuery;
+  }
+  return {
+    ...baseQuery,
+    locale: actionLocale
   };
-  const getEntryFromResult = ({
-    resultCandidates,
-    documentId,
-    entriesQuery
-  }) => {
-    const documentCandidates = (resultCandidates || []).filter(
-      (candidate) => candidate?.data?.documentId === documentId
-    );
-    if (documentCandidates.length === 0) return null;
-    const rankedCandidates = rankEntryCandidates(documentCandidates);
-    if (entriesQuery?.status === "draft") {
-      const draftCandidate = rankedCandidates.find(
-        (candidate) => !isPublishedEntry(candidate.data)
-      );
-      return draftCandidate?.data || rankedCandidates[0]?.data || null;
+};
+const resolveLocaleCodesToRemoveFromIndex = ({
+  actionParams,
+  preDeleteStrapiEntry,
+  localeVariants
+}) => {
+  const actionLocale = getActionLocale(actionParams);
+  if (actionLocale && !isWildcardLocale(actionLocale)) {
+    return [actionLocale];
+  }
+  if (actionLocale == null) {
+    return typeof preDeleteStrapiEntry?.locale === "string" && preDeleteStrapiEntry.locale.length > 0 ? [preDeleteStrapiEntry.locale] : [];
+  }
+  return [
+    ...new Set(
+      (localeVariants || []).map((entry) => entry?.locale).filter((locale) => typeof locale === "string" && locale.length > 0)
+    )
+  ];
+};
+const resolveLocaleCodesToRemoveFromActionResult = ({
+  actionParams,
+  resultCandidates,
+  result,
+  documentId
+}) => {
+  const entriesForDocument = (resultCandidates || []).map((candidate) => candidate?.data).filter((entry) => entry?.documentId === documentId);
+  const localeVariants = entriesForDocument.filter(
+    (entry) => typeof entry?.locale === "string" && entry.locale.length > 0
+  ).map((entry) => ({ documentId: entry.documentId, locale: entry.locale }));
+  const preDeleteStrapiEntry = entriesForDocument.find(
+    (entry) => typeof entry?.locale === "string" && entry.locale.length > 0
+  ) ?? (typeof result?.locale === "string" && result.locale.length > 0 ? result : entriesForDocument[0] ?? null);
+  return resolveLocaleCodesToRemoveFromIndex({
+    actionParams,
+    preDeleteStrapiEntry,
+    localeVariants
+  });
+};
+const collectLocaleCodesFromEntries = (entries) => {
+  return [
+    ...new Set(
+      (entries || []).map((entry) => entry?.locale).filter((locale) => typeof locale === "string" && locale.length > 0)
+    )
+  ];
+};
+const selectStrapiEntryToIndexFromResult = ({
+  resultCandidates,
+  documentId,
+  syncQuery,
+  actionParams
+}) => {
+  const strapiDocumentEntryCandidates = (resultCandidates || []).filter(
+    (candidate) => candidate?.data?.documentId === documentId
+  );
+  if (strapiDocumentEntryCandidates.length === 0) return null;
+  const rankedEntryCandidates = rankStrapiEntryCandidates(
+    strapiDocumentEntryCandidates
+  );
+  const preferredConcreteLocale = resolvePreferredConcreteLocale({
+    syncQuery,
+    actionParams
+  });
+  const localeScopedEntryCandidate = preferredConcreteLocale ? rankedEntryCandidates.find(
+    (candidate) => candidate?.data?.locale === preferredConcreteLocale
+  ) : null;
+  if (syncQuery?.status === "draft") {
+    const isIndexableDraftEntryCandidate = (candidate) => candidate?.data?.id != null && !isPublishedStrapiEntry(candidate.data);
+    if (preferredConcreteLocale) {
+      return localeScopedEntryCandidate && isIndexableDraftEntryCandidate(localeScopedEntryCandidate) ? localeScopedEntryCandidate.data : null;
     }
-    const publishedCandidate = rankedCandidates.find(
-      (candidate) => isPublishedEntry(candidate.data)
+    const draftEntryCandidate = rankedEntryCandidates.find(
+      isIndexableDraftEntryCandidate
     );
-    return publishedCandidate?.data || null;
-  };
-  const getEntryOutsideTransaction = ({
-    contentTypeService: contentTypeService2,
+    return draftEntryCandidate?.data || null;
+  }
+  if (preferredConcreteLocale) {
+    return localeScopedEntryCandidate && isPublishedStrapiEntry(localeScopedEntryCandidate.data) ? localeScopedEntryCandidate.data : null;
+  }
+  const publishedEntryCandidate = rankedEntryCandidates.find(
+    (candidate) => isPublishedStrapiEntry(candidate.data)
+  );
+  return publishedEntryCandidate?.data || null;
+};
+const selectDraftEntriesForDiscardDraftResult = ({
+  resultCandidates,
+  documentId,
+  actionParams
+}) => {
+  const actionLocale = getActionLocale(actionParams);
+  const rankedDraftEntryCandidates = rankStrapiEntryCandidates(
+    (resultCandidates || []).filter(
+      (candidate) => candidate?.data?.documentId === documentId && !isPublishedStrapiEntry(candidate.data)
+    )
+  );
+  const rankedLocalizedDraftEntryCandidates = rankedDraftEntryCandidates.filter(
+    (candidate) => typeof candidate?.data?.locale === "string" && candidate.data.locale.length > 0
+  );
+  if (rankedDraftEntryCandidates.length === 0) return [];
+  if (actionLocale && !isWildcardLocale(actionLocale)) {
+    const localeCandidate = rankedLocalizedDraftEntryCandidates.find(
+      (candidate) => candidate?.data?.locale === actionLocale
+    );
+    return localeCandidate ? [localeCandidate.data] : [];
+  }
+  if (actionLocale && isWildcardLocale(actionLocale)) {
+    const entriesByLocale = /* @__PURE__ */ new Map();
+    rankedLocalizedDraftEntryCandidates.forEach((candidate) => {
+      const locale = candidate.data.locale;
+      if (!entriesByLocale.has(locale)) {
+        entriesByLocale.set(locale, candidate.data);
+      }
+    });
+    return [...entriesByLocale.values()];
+  }
+  return [
+    rankedLocalizedDraftEntryCandidates[0]?.data || rankedDraftEntryCandidates[0].data
+  ];
+};
+const selectPublishedEntriesForWildcardPublish = ({
+  resultCandidates,
+  documentId,
+  actionParams,
+  syncQuery
+}) => {
+  const actionLocale = getActionLocale(actionParams);
+  const syncLocale = syncQuery?.locale;
+  const syncStatusScope = syncQuery?.status;
+  const syncAllowsPublishedEntries = syncStatusScope == null || syncStatusScope !== "draft";
+  if (!actionLocale || !isWildcardLocale(actionLocale) || !isWildcardLocale(syncLocale) || !syncAllowsPublishedEntries) {
+    return [];
+  }
+  const rankedPublishedEntryCandidates = rankStrapiEntryCandidates(
+    (resultCandidates || []).filter(
+      (candidate) => candidate?.data?.documentId === documentId && isPublishedStrapiEntry(candidate.data)
+    )
+  );
+  if (rankedPublishedEntryCandidates.length === 0) return [];
+  const selectedEntries = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  rankedPublishedEntryCandidates.forEach((candidate) => {
+    const strapiEntry = candidate?.data;
+    if (!strapiEntry || typeof strapiEntry !== "object") return;
+    const localeKey = typeof strapiEntry.locale === "string" && strapiEntry.locale.length > 0 ? `locale:${strapiEntry.locale}` : null;
+    const idKey = strapiEntry.id != null ? `id:${strapiEntry.id}` : null;
+    const dedupeKey = localeKey || idKey;
+    if (!dedupeKey || seenKeys.has(dedupeKey)) return;
+    seenKeys.add(dedupeKey);
+    selectedEntries.push(strapiEntry);
+  });
+  return selectedEntries;
+};
+const getStrapiEntryAfterTransaction = ({
+  contentTypeService: contentTypeService2,
+  contentType: contentType2,
+  documentId,
+  syncQuery
+}) => new Promise((resolve, reject) => {
+  setImmediate(async () => {
+    try {
+      const strapiEntry = await contentTypeService2.getEntry({
+        contentType: contentType2,
+        documentId,
+        entriesQuery: { ...syncQuery }
+      });
+      resolve(strapiEntry);
+    } catch (error2) {
+      reject(error2);
+    }
+  });
+});
+const buildPreActionSnapshot = async ({
+  contentTypeService: contentTypeService2,
+  contentType: contentType2,
+  documentId,
+  statusFilter,
+  actionParams,
+  indexSyncUsesWildcardLocale
+}) => {
+  const preDeleteStrapiEntry = await contentTypeService2.getEntry({
     contentType: contentType2,
     documentId,
-    entriesQuery
-  }) => new Promise((resolve, reject) => {
-    setImmediate(async () => {
-      try {
-        const entry = await contentTypeService2.getEntry({
-          contentType: contentType2,
-          documentId,
-          entriesQuery: { ...entriesQuery }
-        });
-        resolve(entry);
-      } catch (error2) {
-        reject(error2);
-      }
+    entriesQuery: { ...statusFilter || {} }
+  });
+  const shouldFetchLocaleVariants = indexSyncUsesWildcardLocale && isWildcardLocale(actionParams?.locale);
+  const localeVariants = shouldFetchLocaleVariants ? await contentTypeService2.getEntries({
+    contentType: contentType2,
+    fields: ["documentId", "locale"],
+    locale: "*",
+    ...statusFilter || {},
+    filters: {
+      documentId
+    }
+  }) : [];
+  const localeCodesToRemove = indexSyncUsesWildcardLocale ? resolveLocaleCodesToRemoveFromIndex({
+    actionParams,
+    preDeleteStrapiEntry,
+    localeVariants
+  }) : [];
+  return {
+    documentId,
+    preDeleteStrapiEntry,
+    localeVariants,
+    localeCodesToRemove
+  };
+};
+const collectPreActionSnapshots = async ({
+  documentIds,
+  contentTypeService: contentTypeService2,
+  contentType: contentType2,
+  statusFilter,
+  actionParams,
+  indexSyncUsesWildcardLocale
+}) => {
+  return Promise.all(
+    documentIds.map(
+      (documentId) => buildPreActionSnapshot({
+        contentTypeService: contentTypeService2,
+        contentType: contentType2,
+        documentId,
+        statusFilter,
+        actionParams,
+        indexSyncUsesWildcardLocale
+      })
+    )
+  );
+};
+const normalizeLocaleCodes = (localeCodes) => {
+  return [
+    ...new Set(
+      (localeCodes || []).filter((locale) => typeof locale === "string" && locale.length > 0).map((locale) => locale.trim())
+    )
+  ];
+};
+const dispatchDeleteTargets = async ({
+  meilisearch: meilisearch2,
+  contentType: contentType2,
+  syncQuery,
+  indexSyncUsesWildcardLocale,
+  targets
+}) => {
+  const validTargets = (targets || []).filter(
+    (target) => target && typeof target.documentId === "string" && target.documentId.length > 0
+  );
+  if (validTargets.length === 0) return;
+  const groupedTargets = /* @__PURE__ */ new Map();
+  validTargets.forEach((target) => {
+    const localeCodes = indexSyncUsesWildcardLocale ? normalizeLocaleCodes(target.localeCodes) : [];
+    const groupKey = localeCodes.length > 0 ? [...localeCodes].sort().join("|") : "__no-locales__";
+    const currentGroup = groupedTargets.get(groupKey);
+    if (currentGroup) {
+      currentGroup.documentIds.push(target.documentId);
+      return;
+    }
+    groupedTargets.set(groupKey, {
+      documentIds: [target.documentId],
+      localeCodes
     });
   });
+  for (const group of groupedTargets.values()) {
+    await meilisearch2.deleteEntriesFromMeiliSearch({
+      contentType: contentType2,
+      documentIds: [...new Set(group.documentIds)],
+      entriesQuery: syncQuery,
+      locales: indexSyncUsesWildcardLocale && group.localeCodes.length > 0 ? group.localeCodes : void 0
+    });
+  }
+};
+async function registerDocumentMiddleware({ strapi: strapi2 }) {
+  if (!strapi2?.documents || typeof strapi2.documents.use !== "function") {
+    return;
+  }
   strapi2.documents.use(async (ctx, next) => {
     let result;
     try {
@@ -425,83 +708,186 @@ async function registerDocumentMiddleware({ strapi: strapi2 }) {
         "unpublish",
         "discardDraft"
       ];
-      const entriesQuery = meilisearch2.entriesQuery({ contentType: contentType2 });
-      const shouldDeleteByLocale = isWildcardLocale(entriesQuery.locale);
-      const { status } = entriesQuery || {};
+      const syncQuery = meilisearch2.entriesQuery({ contentType: contentType2 });
+      const indexSyncUsesWildcardLocale = isWildcardLocale(syncQuery.locale);
+      const { status } = syncQuery || {};
       const statusFilter = typeof status === "string" && status.length > 0 ? { status } : {};
-      const preDeleteDocumentId = deleteActions.includes(ctx.action) && ctx?.params?.documentId ? ctx.params.documentId : null;
-      let preDeleteEntry = null;
-      let preDeleteLocales = [];
-      if (preDeleteDocumentId != null) {
-        preDeleteEntry = await contentTypeService2.getEntry({
-          contentType: contentType2,
-          documentId: preDeleteDocumentId,
-          entriesQuery: { ...statusFilter }
-        });
-        if (shouldDeleteByLocale) {
-          const localeVariants = await contentTypeService2.getEntries({
-            contentType: contentType2,
-            fields: ["documentId", "locale"],
-            locale: "*",
-            ...statusFilter,
-            filters: {
-              documentId: preDeleteDocumentId
+      const isDraftIndex = status === "draft";
+      const isPublishedIndex = status === "published";
+      const shouldSkipDeleteAction = ctx.action === "unpublish" && isDraftIndex || ctx.action === "discardDraft" && isPublishedIndex;
+      const shouldTreatAsUpdateAction = updateActions.includes(ctx.action) || ctx.action === "discardDraft" && isDraftIndex;
+      const shouldTreatAsDeleteAction = deleteActions.includes(ctx.action) && !shouldTreatAsUpdateAction && !shouldSkipDeleteAction;
+      const preActionDocumentIds = resolveDocumentIdsFromActionParams(
+        ctx?.params
+      );
+      const shouldCollectPreActionSnapshots = shouldTreatAsDeleteAction || ctx.action === "discardDraft" && isDraftIndex;
+      const preActionSnapshots = shouldCollectPreActionSnapshots ? await collectPreActionSnapshots({
+        documentIds: preActionDocumentIds,
+        contentTypeService: contentTypeService2,
+        contentType: contentType2,
+        statusFilter,
+        actionParams: ctx?.params,
+        indexSyncUsesWildcardLocale
+      }) : [];
+      const preActionSnapshotsByDocumentId = new Map(
+        preActionSnapshots.map((snapshot) => [snapshot.documentId, snapshot])
+      );
+      result = await next();
+      const documentIds = resolveDocumentIds({
+        actionParams: ctx?.params,
+        result,
+        preActionSnapshots
+      });
+      if (shouldTreatAsUpdateAction && documentIds.length > 0) {
+        const resultCandidates = extractStrapiEntryCandidates(result);
+        const entriesToUpdate = [];
+        const deleteTargets = [];
+        for (const documentId of documentIds) {
+          if (ctx.action === "discardDraft" && isDraftIndex) {
+            const preActionSnapshot = preActionSnapshotsByDocumentId.get(documentId) || null;
+            const actionLocale = getActionLocale(ctx?.params);
+            const shouldLoadDraftEntriesAcrossLocales = indexSyncUsesWildcardLocale && isWildcardLocale(actionLocale);
+            const draftEntriesFromResult = selectDraftEntriesForDiscardDraftResult({
+              resultCandidates,
+              documentId,
+              actionParams: ctx?.params
+            });
+            let draftEntriesToUpdate = shouldLoadDraftEntriesAcrossLocales ? await contentTypeService2.getEntries({
+              contentType: contentType2,
+              locale: "*",
+              ...statusFilter,
+              filters: {
+                documentId
+              }
+            }) : draftEntriesFromResult;
+            draftEntriesToUpdate = (draftEntriesToUpdate || []).filter(
+              (entry) => entry && !isPublishedStrapiEntry(entry)
+            );
+            if (draftEntriesToUpdate.length === 0 && shouldLoadDraftEntriesAcrossLocales) {
+              draftEntriesToUpdate = draftEntriesFromResult;
+            }
+            if (draftEntriesToUpdate.length === 0 && !shouldLoadDraftEntriesAcrossLocales) {
+              const fallbackStrapiEntry = await getStrapiEntryAfterTransaction({
+                contentTypeService: contentTypeService2,
+                contentType: contentType2,
+                documentId,
+                syncQuery: resolveLocaleScopedReadQuery({
+                  syncQuery,
+                  actionParams: ctx?.params
+                })
+              });
+              if (fallbackStrapiEntry && !isPublishedStrapiEntry(fallbackStrapiEntry)) {
+                draftEntriesToUpdate = [fallbackStrapiEntry];
+              }
             }
+            if (draftEntriesToUpdate.length > 0) {
+              const normalizedDraftEntries = draftEntriesToUpdate.map(
+                (entry) => entry.documentId === documentId ? entry : { ...entry, documentId }
+              );
+              entriesToUpdate.push(...normalizedDraftEntries);
+            }
+            const preActionLocaleCodes = resolveLocaleCodesToRemoveFromIndex({
+              actionParams: ctx?.params,
+              preDeleteStrapiEntry: preActionSnapshot?.preDeleteStrapiEntry || null,
+              localeVariants: preActionSnapshot?.localeVariants || []
+            });
+            const remainingLocaleCodes = collectLocaleCodesFromEntries(draftEntriesToUpdate);
+            const localeCodesToDelete = preActionLocaleCodes.filter(
+              (localeCode) => !remainingLocaleCodes.includes(localeCode)
+            );
+            if (localeCodesToDelete.length > 0) {
+              deleteTargets.push({
+                documentId,
+                localeCodes: localeCodesToDelete
+              });
+            }
+            continue;
+          }
+          let entriesForDocument = [];
+          const publishedEntriesFromWildcardPublish = selectPublishedEntriesForWildcardPublish({
+            resultCandidates,
+            documentId,
+            actionParams: ctx?.params,
+            syncQuery
           });
-          preDeleteLocales = [
-            ...new Set(
-              localeVariants.map((entry) => entry?.locale).filter(
-                (locale) => typeof locale === "string" && locale.length > 0
-              )
-            )
-          ];
-        }
-      }
-      result = await next();
-      const contextDocumentId = typeof ctx?.params?.documentId === "string" && ctx.params.documentId.length > 0 ? ctx.params.documentId : null;
-      const documentId = contextDocumentId ?? result?.documentId ?? preDeleteEntry?.documentId ?? preDeleteDocumentId ?? null;
-      if (updateActions.includes(ctx.action) && documentId != null) {
-        const resultCandidates = extractEntryCandidates(result);
-        let entry = getEntryFromResult({
-          resultCandidates,
-          documentId,
-          entriesQuery
-        });
-        if (!entry) {
-          entry = await getEntryOutsideTransaction({
-            contentTypeService: contentTypeService2,
-            contentType: contentType2,
+          if (publishedEntriesFromWildcardPublish.length > 0) {
+            entriesForDocument = publishedEntriesFromWildcardPublish;
+          }
+          let strapiEntry = selectStrapiEntryToIndexFromResult({
+            resultCandidates,
             documentId,
-            entriesQuery
+            syncQuery,
+            actionParams: ctx?.params
           });
+          if (entriesForDocument.length === 0 && !strapiEntry) {
+            strapiEntry = await getStrapiEntryAfterTransaction({
+              contentTypeService: contentTypeService2,
+              contentType: contentType2,
+              documentId,
+              syncQuery: resolveLocaleScopedReadQuery({
+                syncQuery,
+                actionParams: ctx?.params
+              })
+            });
+          }
+          if (entriesForDocument.length === 0 && strapiEntry) {
+            entriesForDocument = [strapiEntry];
+          }
+          if (entriesForDocument.length > 0) {
+            const normalizedEntries = entriesForDocument.map(
+              (entry) => entry.documentId === documentId ? entry : { ...entry, documentId }
+            );
+            entriesToUpdate.push(...normalizedEntries);
+          } else if (ctx.action === "create" || ctx.action === "publish") {
+            const createPublishLocaleCodesToRemove = indexSyncUsesWildcardLocale ? resolveLocaleCodesToRemoveFromActionResult({
+              actionParams: ctx?.params,
+              resultCandidates,
+              result,
+              documentId
+            }) : [];
+            deleteTargets.push({
+              documentId,
+              localeCodes: createPublishLocaleCodesToRemove
+            });
+          } else {
+            strapi2.log.info(
+              `Meilisearch document middleware skipped indexing ${contentType2} documentId=${documentId} for action ${ctx.action}: no indexable Strapi entry in action result`
+            );
+          }
         }
-        if (entry) {
-          const normalizedEntry = entry.documentId === documentId ? entry : { ...entry, documentId };
+        if (entriesToUpdate.length > 0) {
           await meilisearch2.updateEntriesInMeilisearch({
             contentType: contentType2,
-            entries: [normalizedEntry]
+            entries: entriesToUpdate
           });
-        } else if (ctx.action === "create" || ctx.action === "publish") {
-          await meilisearch2.deleteEntriesFromMeiliSearch({
+        }
+        if (deleteTargets.length > 0) {
+          await dispatchDeleteTargets({
+            meilisearch: meilisearch2,
             contentType: contentType2,
-            documentIds: [documentId],
-            entriesQuery
+            syncQuery,
+            indexSyncUsesWildcardLocale,
+            targets: deleteTargets
           });
-        } else {
-          strapi2.log.info(
-            `Meilisearch document middleware skipped indexing ${contentType2} documentId=${documentId} for action ${ctx.action}: no indexable entry in result payload`
-          );
         }
-      } else if (deleteActions.includes(ctx.action)) {
-        if (documentId != null) {
+      } else if (shouldTreatAsDeleteAction) {
+        if (documentIds.length > 0) {
+          const deleteTargets = documentIds.map((documentId) => {
+            const preActionSnapshot = preActionSnapshotsByDocumentId.get(documentId) || null;
+            return {
+              documentId,
+              localeCodes: indexSyncUsesWildcardLocale ? preActionSnapshot?.localeCodesToRemove || [] : []
+            };
+          });
           strapi2.log.info(
-            `Meilisearch document middleware deleting ${contentType2} documentId=${documentId}`
+            `Meilisearch document middleware deleting ${contentType2} documentIds=${documentIds.join(",")}`
           );
-          await meilisearch2.deleteEntriesFromMeiliSearch({
+          await dispatchDeleteTargets({
+            meilisearch: meilisearch2,
             contentType: contentType2,
-            documentIds: [documentId],
-            entriesQuery,
-            locales: shouldDeleteByLocale && preDeleteLocales.length > 0 ? preDeleteLocales : void 0
+            syncQuery,
+            indexSyncUsesWildcardLocale,
+            targets: deleteTargets
           });
         } else {
           strapi2.log.info(
@@ -1636,7 +2022,7 @@ const store = ({ strapi: strapi2 }) => {
     ...createStoreConnector({ strapi: strapi2 })
   };
 };
-const version = "0.16.2";
+const version = "0.16.3";
 const Meilisearch = (config2) => {
   return new meilisearch$1.MeiliSearch({
     ...config2,