@tunghtml/strapi-plugin-filtered-relation 1.1.6 → 1.1.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.1.7] - 2026-10-19
+
+### Fixed
+
+- Removed the auto-save that could never run in Strapi 5 (it needed `contentType`/`model` props the Content Manager does not pass) and sent a wrongly shaped payload
+- Hooks no longer run after an early return
+
+### Changed
+
+- The lifecycle hook collects filtered-relation fields once instead of scanning every content type on each database write
+- Split the hook into small functions, removed unused variables and the nested ternary in the field render
+
 ## [1.1.3] - 2024-12-02
 
 ### Changed

package/admin/src/components/FilteredRelationInput.jsx

@@ -22,10 +22,6 @@ const FilteredRelationInput = (props) => {
   const [statusOptions, setStatusOptions] = React.useState([]);
   const [updatingStatus, setUpdatingStatus] = React.useState({});
 
-  if (!props) {
-    return null;
-  }
-
   const { attribute, name, error, value } = props;
 
   // Extract documentId from URL path
@@ -85,25 +81,6 @@ const FilteredRelationInput = (props) => {
     filterParams[filterField2] = value2;
   }
 
-  const contentType = props.contentType || props.model;
-
-  const saveFieldValue = async (newValue) => {
-    if (!documentId || !contentType) return;
-
-    try {
-      await put(
-        `/content-manager/collection-types/${contentType}/${documentId}`,
-        {
-          data: {
-            [name]: newValue,
-          },
-        }
-      );
-    } catch (err) {
-      console.error("Error auto-saving filtered relation:", err);
-    }
-  };
-
   // Fetch status options from target model schema
   React.useEffect(() => {
     const fetchStatusOptions = async () => {
@@ -121,8 +98,8 @@ const FilteredRelationInput = (props) => {
           );
           const builderSchema = builderResponse?.data?.data?.schema;
           enumValues = builderSchema?.attributes?.[statusField]?.enum;
-        } catch (e) {
-          // Endpoint might not be accessible, try next
+        } catch {
+          // Endpoint might not be accessible: no status options then
         }
 
         if (enumValues && Array.isArray(enumValues)) {
@@ -254,7 +231,7 @@ const FilteredRelationInput = (props) => {
       };
 
       // Use disconnect with full payload
-      const removeResponse = await put(
+      await put(
         `/content-manager/collection-types/${targetModel}/${itemId}`,
         updatePayload
       );
@@ -276,7 +253,7 @@ const FilteredRelationInput = (props) => {
       };
 
       // Use connect with full payload
-      const addResponse = await put(
+      await put(
         `/content-manager/collection-types/${targetModel}/${targetRecordId}`,
         addPayload
       );
@@ -329,11 +306,6 @@ const FilteredRelationInput = (props) => {
         })
         .join("&");
 
-      const populateFields = [displayField];
-      if (statusField) {
-        populateFields.push(statusField);
-      }
-
       const apiUrl = `/content-manager/collection-types/${targetModel}?${filterQuery}&populate[${displayField}][populate]=*`;
       const response = await get(apiUrl);
       const items =
@@ -404,21 +376,8 @@ const FilteredRelationInput = (props) => {
         });
 
         setItems(formattedItems);
-
-        // Auto-save to database
-        const documentIds = formattedItems.map(
-          (item) => item.relatedDocumentId || item.id
-        );
-        const newValue = JSON.stringify(documentIds);
-
-        if (documentId && value !== newValue) {
-          await saveFieldValue(newValue);
-        }
       } else {
         setItems([]);
-        if (documentId && value) {
-          await saveFieldValue(null);
-        }
       }
     } catch (err) {
       console.error("Error fetching filtered relations:", err);
@@ -458,83 +417,92 @@ const FilteredRelationInput = (props) => {
   const fieldLabel = props.label || name;
   const itemCount = items.length;
 
+  let content;
+  if (loading) {
+    content = (
+      <Typography variant="omega" textColor="neutral600">
+        {formatMessage({
+          id: "filtered-relation.loading",
+          defaultMessage: "Loading...",
+        })}
+      </Typography>
+    );
+  } else if (items.length > 0) {
+    content = (
+      <Flex direction="column" alignItems="stretch" gap={1}>
+        {items.map((item) => {
+          const editUrl = `/content-manager/collection-types/${item.relationModel}/${item.relatedDocumentId}`;
+          const isUpdating = updatingStatus[item.originalId];
+
+          return (
+            <Box
+              key={item.id}
+              background="neutral0"
+              borderColor="neutral200"
+              borderStyle="solid"
+              borderWidth="1px"
+              hasRadius
+              paddingTop={2}
+              paddingBottom={2}
+              paddingLeft={4}
+              paddingRight={4}
+              style={{
+                cursor: "pointer",
+                minHeight: "50px",
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "space-between",
+              }}
+              onClick={() => navigate(editUrl)}
+            >
+              <Typography variant="omega" textColor="primary600">
+                {item.label}
+              </Typography>
+
+              {statusField && statusOptions.length > 0 && (
+                <Box
+                  onClick={(e) => e.stopPropagation()}
+                  style={{ minWidth: "150px" }}
+                >
+                  <SingleSelect
+                    size="S"
+                    value={item.currentStatus}
+                    onChange={(value) =>
+                      handleStatusChange(item.originalId, value, null)
+                    }
+                    disabled={isUpdating}
+                  >
+                    {statusOptions.map((status) => (
+                      <SingleSelectOption key={status} value={status}>
+                        {status}
+                      </SingleSelectOption>
+                    ))}
+                  </SingleSelect>
+                </Box>
+              )}
+            </Box>
+          );
+        })}
+      </Flex>
+    );
+  } else {
+    content = (
+      <Typography variant="omega" textColor="neutral600">
+        {formatMessage({
+          id: "filtered-relation.no-results",
+          defaultMessage: "No matching records found",
+        })}
+      </Typography>
+    );
+  }
+
   return (
     <Field.Root name={name} error={error}>
       <Flex direction="column" alignItems="stretch" gap={1}>
         <Field.Label>
           {fieldLabel} {itemCount > 0 && `(${itemCount})`}
         </Field.Label>
-        {loading ? (
-          <Typography variant="omega" textColor="neutral600">
-            {formatMessage({
-              id: "filtered-relation.loading",
-              defaultMessage: "Loading...",
-            })}
-          </Typography>
-        ) : items.length > 0 ? (
-          <Flex direction="column" alignItems="stretch" gap={1}>
-            {items.map((item) => {
-              const editUrl = `/content-manager/collection-types/${item.relationModel}/${item.relatedDocumentId}`;
-              const isUpdating = updatingStatus[item.originalId];
-
-              return (
-                <Box
-                  key={item.id}
-                  background="neutral0"
-                  borderColor="neutral200"
-                  borderStyle="solid"
-                  borderWidth="1px"
-                  hasRadius
-                  paddingTop={2}
-                  paddingBottom={2}
-                  paddingLeft={4}
-                  paddingRight={4}
-                  style={{
-                    cursor: "pointer",
-                    minHeight: "50px",
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "space-between",
-                  }}
-                  onClick={() => navigate(editUrl)}
-                >
-                  <Typography variant="omega" textColor="primary600">
-                    {item.label}
-                  </Typography>
-
-                  {statusField && statusOptions.length > 0 && (
-                    <Box
-                      onClick={(e) => e.stopPropagation()}
-                      style={{ minWidth: "150px" }}
-                    >
-                      <SingleSelect
-                        size="S"
-                        value={item.currentStatus}
-                        onChange={(value) =>
-                          handleStatusChange(item.originalId, value, null)
-                        }
-                        disabled={isUpdating}
-                      >
-                        {statusOptions.map((status) => (
-                          <SingleSelectOption key={status} value={status}>
-                            {status}
-                          </SingleSelectOption>
-                        ))}
-                      </SingleSelect>
-                    </Box>
-                  )}
-                </Box>
-              );
-            })}
-          </Flex>
-        ) : (
-          <Typography variant="omega" textColor="neutral600">
-            {formatMessage({
-              id: "filtered-relation.no-results",
-              defaultMessage: "No matching records found",
-            })}
-          </Typography>
-        )}
+        {content}
         <Field.Hint>
           <Typography variant="pi" textColor="neutral600">
             {Object.keys(filterParams).length > 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tunghtml/strapi-plugin-filtered-relation",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "A Strapi custom field plugin for displaying filtered relations with dynamic placeholder support and status change capability",
   "keywords": [
     "strapi",

package/server/register.js

@@ -23,93 +23,93 @@ module.exports = ({ strapi }) => {
   });
 };
 
+const FILTERED_RELATION_UID = "plugin::filtered-relation.filtered-relation";
+
+// Parse collection name to API ID
+const parseCollectionName = (name) => {
+  if (!name) return null;
+  if (name.startsWith("api::")) return name;
+  const slug = name
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "");
+  return `api::${slug}.${slug}`;
+};
+
+// Static filters only: values bound to the current document cannot be resolved here
+const buildStaticFilters = ({
+  filterField1,
+  filterValue1,
+  filterField2,
+  filterValue2,
+}) => {
+  const filterParams = {};
+  if (filterField1 && filterValue1 && filterValue1 !== "{{documentId}}") {
+    filterParams[filterField1] = filterValue1;
+  }
+  if (filterField2 && filterValue2 && filterValue2 !== "{{documentId}}") {
+    filterParams[filterField2] = filterValue2;
+  }
+  return filterParams;
+};
+
+// Schemas are fixed once Strapi is running, so the filtered-relation fields are collected once
+let filteredRelationFields = null;
+
+function getFilteredRelationFields(strapi) {
+  if (filteredRelationFields) return filteredRelationFields;
+
+  filteredRelationFields = [];
+  for (const uid of Object.keys(strapi.contentTypes)) {
+    if (!uid.startsWith("api::")) continue;
+
+    const schema = strapi.getModel(uid);
+    for (const [fieldName, fieldConfig] of Object.entries(
+      schema?.attributes || {},
+    )) {
+      if (fieldConfig.customField !== FILTERED_RELATION_UID) continue;
+
+      const options = fieldConfig.options || {};
+      filteredRelationFields.push({
+        uid,
+        schema,
+        fieldName,
+        targetModel: parseCollectionName(options.targetModel),
+        filterParams: buildStaticFilters(options),
+        displayField: options.displayField,
+      });
+    }
+  }
+  return filteredRelationFields;
+}
+
 async function updateRelatedFilteredFields(event, strapi) {
   const { model } = event;
   if (!model) return;
 
-  const currentModelUid = model.uid;
-
   try {
-    // Get all content types to find which ones have filtered-relation fields
-    const contentTypes = strapi.contentTypes;
-
-    for (const [uid, contentType] of Object.entries(contentTypes)) {
-      // Skip non-API content types
-      if (!uid.startsWith("api::")) continue;
-
-      const schema = strapi.getModel(uid);
-      if (!schema?.attributes) continue;
-
-      // Find filtered-relation fields that target the current model
-      for (const [fieldName, fieldConfig] of Object.entries(
-        schema.attributes,
-      )) {
-        if (
-          fieldConfig.customField ===
-          "plugin::filtered-relation.filtered-relation"
-        ) {
-          const {
-            targetModel: targetModelInput,
-            filterField1,
-            filterValue1,
-            filterField2,
-            filterValue2,
-            displayField,
-          } = fieldConfig.options || {};
-
-          // Parse collection name to API ID
-          const parseCollectionName = (name) => {
-            if (!name) return null;
-            if (name.startsWith("api::")) return name;
-            const slug = name
-              .toLowerCase()
-              .replace(/\s+/g, "-")
-              .replace(/[^a-z0-9-]/g, "");
-            return `api::${slug}.${slug}`;
-          };
-
-          const targetModel = parseCollectionName(targetModelInput);
-
-          // Build filter params
-          const filterParams = {};
-          if (
-            filterField1 &&
-            filterValue1 &&
-            filterValue1 !== "{{documentId}}"
-          ) {
-            filterParams[filterField1] = filterValue1;
-          }
-          if (
-            filterField2 &&
-            filterValue2 &&
-            filterValue2 !== "{{documentId}}"
-          ) {
-            filterParams[filterField2] = filterValue2;
-          }
-
-          // Check if this field targets the model that was just modified
-          if (targetModel === currentModelUid) {
-            // Find all related entities that need updating
-            const relatedEntities = await findRelatedEntities(
-              event,
-              schema,
-              uid,
-            );
-
-            // Update each related entity
-            for (const entityId of relatedEntities) {
-              await updateFilteredField(
-                strapi,
-                uid,
-                entityId,
-                fieldName,
-                targetModel,
-                filterParams,
-                displayField,
-              );
-            }
-          }
-        }
+    const fields = getFilteredRelationFields(strapi).filter(
+      (field) => field.targetModel === model.uid,
+    );
+
+    for (const field of fields) {
+      // Find all related entities that need updating
+      const relatedEntities = await findRelatedEntities(
+        event,
+        field.schema,
+        field.uid,
+      );
+
+      for (const entityId of relatedEntities) {
+        await updateFilteredField(
+          strapi,
+          field.uid,
+          entityId,
+          field.fieldName,
+          field.targetModel,
+          field.filterParams,
+          field.displayField,
+        );
       }
     }
   } catch (error) {