@tunghtml/strapi-plugin-filtered-relation 1.0.0

package/README.md

@@ -0,0 +1,113 @@
+# Strapi Plugin Filtered Relation
+
+A Strapi v5 custom field plugin that displays filtered relations with dynamic placeholder support.
+
+## Features
+
+- 🎯 **Dynamic Filtering**: Filter relations based on multiple criteria
+- 🔄 **Placeholder Support**: Use `{{documentId}}` to reference current entity
+- 🎨 **Clean UI**: Displays filtered results in a clean, clickable list
+- ⚡ **Auto-save**: Automatically saves filtered results to the field
+- 🔗 **Nested Relations**: Support for filtering through nested relation fields (e.g., `meeting.documentId`)
+
+## Installation
+
+```bash
+npm install @tunghtml/strapi-plugin-filtered-relation
+```
+
+or
+
+```bash
+yarn add @tunghtml/strapi-plugin-filtered-relation
+```
+
+## Usage
+
+### 1. Enable the plugin
+
+Add the plugin to your `config/plugins.js`:
+
+```javascript
+module.exports = {
+  "filtered-relation": {
+    enabled: true,
+  },
+};
+```
+
+### 2. Add to your schema
+
+In your content type schema (e.g., `api/meeting/content-types/meeting/schema.json`):
+
+```json
+{
+  "attributes": {
+    "rejectedInvestors": {
+      "type": "customField",
+      "customField": "plugin::filtered-relation.filtered-relation",
+      "options": {
+        "targetModel": "Meeting Participation Status",
+        "displayField": "investors",
+        "filterField1": "participantStatus",
+        "filterValue1": "Rejected",
+        "filterField2": "meeting.documentId",
+        "filterValue2": "{{documentId}}"
+      }
+    }
+  }
+}
+```
+
+## Configuration Options
+
+| Option         | Type   | Description                                            | Example                          |
+| -------------- | ------ | ------------------------------------------------------ | -------------------------------- |
+| `targetModel`  | string | The target collection to query                         | `"Meeting Participation Status"` |
+| `displayField` | string | The field to display from results                      | `"investors"`                    |
+| `filterField1` | string | First filter field (supports nested with dot notation) | `"participantStatus"`            |
+| `filterValue1` | string | Value for first filter                                 | `"Rejected"`                     |
+| `filterField2` | string | Second filter field (optional)                         | `"meeting.documentId"`           |
+| `filterValue2` | string | Value for second filter (supports `{{documentId}}`)    | `"{{documentId}}"`               |
+
+## Dynamic Placeholders
+
+Use `{{documentId}}` in filter values to reference the current entity's document ID:
+
+```json
+{
+  "filterField2": "meeting.documentId",
+  "filterValue2": "{{documentId}}"
+}
+```
+
+This will automatically replace `{{documentId}}` with the actual document ID when editing an entity.
+
+## Example Use Case
+
+Display rejected investors for a specific meeting:
+
+1. **Target Model**: Meeting Participation Status
+2. **Display Field**: investors (shows investor names)
+3. **Filter 1**: `participantStatus = "Rejected"`
+4. **Filter 2**: `meeting.documentId = {{documentId}}`
+
+Result: Shows only investors who rejected the current meeting.
+
+## Requirements
+
+- Strapi v5.x
+- Node.js >= 18.0.0
+- React >= 18.0.0
+
+## License
+
+MIT
+
+## Author
+
+Tung HTML
+
+## Repository
+
+[https://github.com/finnwasabi/strapi-plugin-filtered-relation](https://github.com/finnwasabi/strapi-plugin-filtered-relation)

package/admin/src/components/FilteredRelationInput.jsx

@@ -0,0 +1,319 @@
+import React from "react";
+import { useIntl } from "react-intl";
+import { Field, Flex, Box, Typography } from "@strapi/design-system";
+import { useFetchClient } from "@strapi/strapi/admin";
+import { useLocation, useNavigate } from "react-router-dom";
+
+const FilteredRelationInput = (props) => {
+  const { formatMessage } = useIntl();
+  const { get, put } = useFetchClient();
+  const location = useLocation();
+  const navigate = useNavigate();
+  const [items, setItems] = React.useState([]);
+  const [loading, setLoading] = React.useState(false);
+
+  if (!props) {
+    return null;
+  }
+
+  const { attribute, name, error, value } = props;
+
+  // Extract documentId from URL path
+  // URL format: /admin/content-manager/collection-types/api::meeting.meeting/bn0n8em49y7vljg5lrfh2aij
+  const getDocumentIdFromUrl = () => {
+    const pathParts = location.pathname.split("/");
+    // Get the last part of the URL which should be the documentId
+    const lastPart = pathParts[pathParts.length - 1];
+    // Check if it's not 'create' (for new documents)
+    return lastPart !== "create" ? lastPart : null;
+  };
+
+  const documentId = props.documentId || props.id || getDocumentIdFromUrl();
+
+  const {
+    targetModel: targetModelInput,
+    filterField1,
+    filterValue1,
+    filterField2,
+    filterValue2,
+    displayField = "id",
+  } = attribute?.options || {};
+
+  // Parse collection name to API ID
+  // "Meeting Participation Status" -> "api::meeting-participation-status.meeting-participation-status"
+  const parseCollectionName = (name) => {
+    if (!name) return null;
+    // If already API ID format, return as is
+    if (name.startsWith("api::")) return name;
+
+    // Convert display name to API ID
+    const slug = name
+      .toLowerCase()
+      .replace(/\s+/g, "-")
+      .replace(/[^a-z0-9-]/g, "");
+    return `api::${slug}.${slug}`;
+  };
+
+  const targetModel = parseCollectionName(targetModelInput);
+
+  // Parse displayField to get relation model
+  // displayField is like "investors" -> "api::investor.investor"
+  const getRelationModel = (fieldName) => {
+    if (!fieldName) return null;
+    // Remove 's' at the end for plural -> singular
+    const singular = fieldName.endsWith("s")
+      ? fieldName.slice(0, -1)
+      : fieldName;
+    const slug = singular.toLowerCase().replace(/[^a-z0-9-]/g, "");
+    return `api::${slug}.${slug}`;
+  };
+
+  const relationModel = getRelationModel(displayField);
+
+  // Build filter params with dynamic values
+  const filterParams = {};
+  if (filterField1 && filterValue1) {
+    // Support {{documentId}} placeholder for current entity
+    const value1 =
+      filterValue1 === "{{documentId}}" ? documentId : filterValue1;
+    filterParams[filterField1] = value1;
+  }
+  if (filterField2 && filterValue2) {
+    // Support {{documentId}} placeholder for current entity
+    const value2 =
+      filterValue2 === "{{documentId}}" ? documentId : filterValue2;
+    filterParams[filterField2] = value2;
+  }
+
+  // Get the content type from props
+  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);
+    }
+  };
+
+  React.useEffect(() => {
+    const fetchFilteredData = async () => {
+      if (!targetModel || Object.keys(filterParams).length === 0) {
+        return;
+      }
+
+      setLoading(true);
+      try {
+        const modelParts = targetModel.split("::");
+        if (modelParts.length !== 2) {
+          return;
+        }
+
+        // Build filter query string using $and pattern
+        // Example: filters[$and][0][participantStatus][$eq]=Rejected&filters[$and][1][meeting][documentId][$eq]=bn0n8em49y7vljg5lrfh2aij
+        const filterQuery = Object.entries(filterParams)
+          .map(([key, value], index) => {
+            // Check if the key contains a dot (relation field)
+            if (key.includes(".")) {
+              const [relationField, nestedField] = key.split(".");
+              return `filters[$and][${index}][${relationField}][${nestedField}][$eq]=${encodeURIComponent(value)}`;
+            }
+            // Regular field
+            return `filters[$and][${index}][${key}][$eq]=${encodeURIComponent(value)}`;
+          })
+          .join("&");
+
+        const apiUrl = `/content-manager/collection-types/${targetModel}?${filterQuery}&populate[${displayField}][populate]=*`;
+        const response = await get(apiUrl);
+        const items =
+          response?.data?.results || response?.results || response?.data || [];
+
+        if (items.length > 0) {
+          const formattedItems = [];
+
+          items.forEach((item) => {
+            if (displayField && item[displayField]) {
+              // If displayField is an array, create one item per array element
+              if (Array.isArray(item[displayField])) {
+                item[displayField].forEach((rel) => {
+                  const displayValue =
+                    rel.fullName ||
+                    rel.name ||
+                    rel.displayName ||
+                    rel.firstName ||
+                    `ID: ${rel.documentId || rel.id}`;
+
+                  formattedItems.push({
+                    id: `${item.documentId || item.id}-${rel.documentId || rel.id}`,
+                    label: displayValue,
+                    originalId: item.documentId || item.id,
+                    relatedDocumentId: rel.documentId || rel.id,
+                    relationModel: relationModel,
+                  });
+                });
+              }
+              // Handle single relation object
+              else if (
+                typeof item[displayField] === "object" &&
+                item[displayField] !== null
+              ) {
+                if (item[displayField].count !== undefined) {
+                  formattedItems.push({
+                    id: item.id,
+                    label: `${item[displayField].count} items`,
+                  });
+                } else {
+                  const displayValue =
+                    item[displayField].fullName ||
+                    item[displayField].name ||
+                    item[displayField].displayName ||
+                    item[displayField].firstName ||
+                    `ID: ${item[displayField].id}`;
+
+                  formattedItems.push({
+                    id: item.id,
+                    label: displayValue,
+                    originalId: item.documentId || item.id,
+                    relatedDocumentId:
+                      item[displayField].documentId || item[displayField].id,
+                    relationModel: relationModel,
+                  });
+                }
+              }
+            } else {
+              // Fallback if no displayField
+              formattedItems.push({
+                id: item.id,
+                label: `ID: ${item.id}`,
+                originalId: item.documentId || item.id,
+                relatedDocumentId: item.documentId || item.id,
+                relationModel: targetModel,
+              });
+            }
+          });
+
+          setItems(formattedItems);
+
+          // Auto-save to database without requiring user to click Save
+          const documentIds = formattedItems.map(
+            (item) => item.relatedDocumentId || item.id,
+          );
+          const newValue = JSON.stringify(documentIds);
+
+          // Only save if value changed and we have a document ID
+          if (documentId && value !== newValue) {
+            await saveFieldValue(newValue);
+          }
+        } else {
+          // Clear the field if no items found
+          setItems([]);
+          if (documentId && value) {
+            await saveFieldValue(null);
+          }
+        }
+      } catch (err) {
+        console.error("Error fetching filtered relations:", err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchFilteredData();
+  }, [
+    targetModel,
+    filterField1,
+    filterValue1,
+    filterField2,
+    filterValue2,
+    displayField,
+    documentId,
+    value,
+  ]);
+
+  const fieldLabel = props.label || name;
+  const itemCount = items.length;
+
+  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) => {
+              // Use relation model (e.g., api::investor.investor) with relatedDocumentId
+              const editUrl = `/content-manager/collection-types/${item.relationModel}/${item.relatedDocumentId}`;
+
+              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",
+                    height: "50px",
+                    display: "flex",
+                    alignItems: "center",
+                  }}
+                  onClick={() => navigate(editUrl)}
+                >
+                  <Typography variant="omega" textColor="primary600">
+                    {item.label}
+                  </Typography>
+                </Box>
+              );
+            })}
+          </Flex>
+        ) : (
+          <Typography variant="omega" textColor="neutral600">
+            {formatMessage({
+              id: "filtered-relation.no-results",
+              defaultMessage: "No matching records found",
+            })}
+          </Typography>
+        )}
+        <Field.Hint>
+          <Typography variant="pi" textColor="neutral600">
+            {Object.keys(filterParams).length > 0
+              ? `Filters: ${Object.entries(filterParams)
+                  .map(([k, v]) => {
+                    // Show placeholder name if it's a dynamic value
+                    const displayValue =
+                      v === documentId ? "{{current documentId}}" : v;
+                    return `${k} = ${displayValue}`;
+                  })
+                  .join(", ")}`
+              : "No filters configured"}
+          </Typography>
+        </Field.Hint>
+      </Flex>
+      <Field.Error />
+    </Field.Root>
+  );
+};
+
+export default FilteredRelationInput;

package/admin/src/index.js

@@ -0,0 +1 @@
+export { default } from "../../strapi-admin";

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@tunghtml/strapi-plugin-filtered-relation",
+  "version": "1.0.0",
+  "description": "A Strapi custom field plugin for displaying filtered relations with dynamic placeholder support",
+  "keywords": [
+    "strapi",
+    "strapi-plugin",
+    "custom-field",
+    "relation",
+    "filter",
+    "strapi5"
+  ],
+  "homepage": "https://github.com/finnwasabi/strapi-plugin-filtered-relation#readme",
+  "bugs": {
+    "url": "https://github.com/finnwasabi/strapi-plugin-filtered-relation/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/finnwasabi/strapi-plugin-filtered-relation.git"
+  },
+  "strapi": {
+    "name": "filtered-relation",
+    "displayName": "Filtered Relation",
+    "description": "Relation field with filtering capability and dynamic placeholders",
+    "kind": "plugin"
+  },
+  "dependencies": {
+    "@strapi/design-system": "^2.0.0-rc.14",
+    "@strapi/icons": "^2.0.0-rc.14"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^5.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-router-dom": "^6.0.0",
+    "styled-components": "^6.0.0"
+  },
+  "author": {
+    "name": "Tung HTML",
+    "email": "tunghtml@example.com"
+  },
+  "maintainers": [
+    {
+      "name": "Tung HTML",
+      "email": "tunghtml@example.com"
+    }
+  ],
+  "engines": {
+    "node": ">=18.0.0 <=22.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "MIT"
+}

package/server/controllers/content-types.js

@@ -0,0 +1,26 @@
+module.exports = {
+  async find(ctx) {
+    try {
+      const contentTypes = strapi.contentTypes;
+      const apiTypes = [];
+
+      for (const [uid, contentType] of Object.entries(contentTypes)) {
+        if (uid.startsWith("api::")) {
+          apiTypes.push({
+            uid,
+            displayName:
+              contentType.info?.displayName ||
+              contentType.schema?.displayName ||
+              uid.split("::")[1],
+          });
+        }
+      }
+
+      apiTypes.sort((a, b) => a.displayName.localeCompare(b.displayName));
+
+      ctx.body = { data: apiTypes };
+    } catch (error) {
+      ctx.throw(500, error);
+    }
+  },
+};

package/server/controllers/index.js

@@ -0,0 +1,5 @@
+const contentTypes = require("./content-types");
+
+module.exports = {
+  contentTypes,
+};

package/server/register.js

@@ -0,0 +1,186 @@
+module.exports = ({ strapi }) => {
+  strapi.customFields.register({
+    name: "filtered-relation",
+    plugin: "filtered-relation",
+    type: "json",
+  });
+
+  // Register global lifecycle hooks for all content types
+  strapi.db.lifecycles.subscribe({
+    async afterCreate(event) {
+      await updateRelatedFilteredFields(event, strapi);
+    },
+
+    async afterUpdate(event) {
+      await updateRelatedFilteredFields(event, strapi);
+    },
+
+    async afterDelete(event) {
+      await updateRelatedFilteredFields(event, strapi);
+    },
+  });
+};
+
+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
+          // Note: {{documentId}} placeholder cannot be resolved in lifecycle hooks
+          // as we don't have context of which entity is being viewed
+          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,
+              );
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    strapi.log.error("Error updating related filtered fields:", error);
+  }
+}
+
+async function findRelatedEntities(event, schema, contentTypeUid) {
+  const { result, params } = event;
+  const entityIds = new Set();
+
+  // Look for relation fields in the schema that point to the content type
+  for (const [fieldName, fieldConfig] of Object.entries(schema.attributes)) {
+    if (
+      fieldConfig.type === "relation" &&
+      fieldConfig.target === contentTypeUid
+    ) {
+      // Get the related entity ID from result or params
+      const relatedId = result?.[fieldName]?.id || params?.data?.[fieldName];
+      if (relatedId) {
+        entityIds.add(relatedId);
+      }
+    }
+  }
+
+  return Array.from(entityIds);
+}
+
+async function updateFilteredField(
+  strapi,
+  contentTypeUid,
+  entityId,
+  fieldName,
+  targetModel,
+  filterParams,
+  displayField,
+) {
+  try {
+    // Fetch filtered data
+    const filteredItems = await strapi.entityService.findMany(targetModel, {
+      filters: filterParams,
+      populate: [displayField],
+    });
+
+    // Extract documentIds from the display field
+    const documentIds = [];
+    filteredItems.forEach((item) => {
+      if (displayField && item[displayField]) {
+        if (Array.isArray(item[displayField])) {
+          item[displayField].forEach((rel) => {
+            const docId = rel?.documentId || rel?.id;
+            if (docId) documentIds.push(docId);
+          });
+        } else if (item[displayField]?.documentId || item[displayField]?.id) {
+          documentIds.push(
+            item[displayField].documentId || item[displayField].id,
+          );
+        }
+      }
+    });
+
+    // Update the entity
+    await strapi.entityService.update(contentTypeUid, entityId, {
+      data: {
+        [fieldName]: JSON.stringify(documentIds),
+      },
+    });
+  } catch (error) {
+    strapi.log.error(
+      `Error updating filtered field ${fieldName} for ${contentTypeUid}:${entityId}`,
+      error,
+    );
+  }
+}

package/server/routes/index.js

@@ -0,0 +1,11 @@
+module.exports = [
+  {
+    method: "GET",
+    path: "/content-types",
+    handler: "contentTypes.find",
+    config: {
+      policies: [],
+      auth: false,
+    },
+  },
+];

package/server/services/index.js

@@ -0,0 +1 @@
+module.exports = {};

package/strapi-admin.js

@@ -0,0 +1,160 @@
+import React from "react";
+import { Filter } from "@strapi/icons";
+
+const FilteredRelationIcon = () =>
+  React.createElement(
+    "div",
+    {
+      style: {
+        display: "flex",
+        justifyContent: "center",
+        alignItems: "center",
+        width: "32px",
+        height: "24px",
+        borderRadius: "4px",
+        border: "1px solid #ffb3d9",
+        background: "#ffe6f5",
+        fontSize: "14px",
+        fontWeight: "600",
+        color: "#d6006e",
+      },
+    },
+    React.createElement(Filter, { width: "12px", height: "12px" }),
+  );
+
+export default {
+  register(app) {
+    // Register custom field
+    app.customFields.register({
+      name: "filtered-relation",
+      pluginId: "filtered-relation",
+      type: "json",
+      icon: FilteredRelationIcon,
+      intlLabel: {
+        id: "filtered-relation.label",
+        defaultMessage: "Filtered Relation",
+      },
+      intlDescription: {
+        id: "filtered-relation.description",
+        defaultMessage: "Relation field with filtering by field value",
+      },
+      components: {
+        Input: async () => {
+          const component = await import(
+            "./admin/src/components/FilteredRelationInput"
+          );
+          return component;
+        },
+      },
+      options: {
+        base: [
+          {
+            intlLabel: {
+              id: "filtered-relation.displayField.label",
+              defaultMessage: "Display Field",
+            },
+            name: "options.displayField",
+            type: "text",
+            description: {
+              id: "filtered-relation.displayField.description",
+              defaultMessage:
+                "Relation field name to display (e.g., 'investors')",
+            },
+            placeholder: {
+              id: "filtered-relation.displayField.placeholder",
+              defaultMessage: "investors",
+            },
+          },
+        ],
+        advanced: [
+          {
+            sectionTitle: {
+              id: "filtered-relation.section.target",
+              defaultMessage: "Target Collection",
+            },
+            items: [
+              {
+                name: "options.targetModel",
+                type: "text",
+                intlLabel: {
+                  id: "filtered-relation.targetModel.label",
+                  defaultMessage: "Collection Name",
+                },
+                description: {
+                  id: "filtered-relation.targetModel.description",
+                  defaultMessage:
+                    "Collection display name (e.g., 'Meeting Participation Status'). Will auto-convert to API ID.",
+                },
+                placeholder: {
+                  id: "filtered-relation.targetModel.placeholder",
+                  defaultMessage: "Meeting Participation Status",
+                },
+              },
+            ],
+          },
+          {
+            sectionTitle: {
+              id: "filtered-relation.section.filters",
+              defaultMessage: "Filter Conditions",
+            },
+            items: [
+              {
+                name: "options.filterField1",
+                type: "text",
+                intlLabel: {
+                  id: "filtered-relation.filterField1.label",
+                  defaultMessage: "Filter Field 1",
+                },
+                placeholder: {
+                  id: "filtered-relation.filterField1.placeholder",
+                  defaultMessage: "participantStatus",
+                },
+              },
+              {
+                name: "options.filterValue1",
+                type: "text",
+                intlLabel: {
+                  id: "filtered-relation.filterValue1.label",
+                  defaultMessage: "Filter Value 1",
+                },
+                placeholder: {
+                  id: "filtered-relation.filterValue1.placeholder",
+                  defaultMessage: "Rejected",
+                },
+              },
+              {
+                name: "options.filterField2",
+                type: "text",
+                intlLabel: {
+                  id: "filtered-relation.filterField2.label",
+                  defaultMessage: "Filter Field 2 (Optional)",
+                },
+                placeholder: {
+                  id: "filtered-relation.filterField2.placeholder",
+                  defaultMessage: "event",
+                },
+              },
+              {
+                name: "options.filterValue2",
+                type: "text",
+                intlLabel: {
+                  id: "filtered-relation.filterValue2.label",
+                  defaultMessage: "Filter Value 2 (Optional)",
+                },
+                description: {
+                  id: "filtered-relation.filterValue2.description",
+                  defaultMessage:
+                    "Use {{documentId}} to filter by current entity",
+                },
+                placeholder: {
+                  id: "filtered-relation.filterValue2.placeholder",
+                  defaultMessage: "{{documentId}}",
+                },
+              },
+            ],
+          },
+        ],
+      },
+    });
+  },
+};

package/strapi-server.js

@@ -0,0 +1,11 @@
+const register = require("./server/register");
+const controllers = require("./server/controllers");
+const routes = require("./server/routes");
+const services = require("./server/services");
+
+module.exports = {
+  register,
+  controllers,
+  routes,
+  services,
+};