feat: Add support for resolving URL patterns with indexed many-to-many relations.

Author: candidosales

packages/core/server/services/__tests__/url-pattern.test.ts

@@ -62,18 +62,18 @@ describe('url-pattern service', () => {
     const service = urlPatternService({ strapi: global.strapi });
 
     describe('getAllowedFields', () => {
-        it('should include fields from many-to-many relations', () => {
+        it('should include fields from many-to-many relations with index', () => {
             const contentType = global.strapi.contentTypes['api::article.article'];
             const allowedFields = ['string'];
 
             const fields = service.getAllowedFields(contentType, allowedFields);
 
-            expect(fields).toContain('categories.name');
+            expect(fields).toContain('categories[0].name');
         });
     });
 
     describe('resolvePattern', () => {
-        it('should resolve pattern with many-to-many relation using the first item', () => {
+        it('should resolve pattern with many-to-many relation using index', () => {
             const uid = 'api::article.article';
             const entity = {
                 title: 'My Article',
@@ -82,20 +82,36 @@ describe('url-pattern service', () => {
                     { name: 'News' },
                 ],
             };
-            const pattern = '/[categories.name]/[title]';
+            const pattern = '/[categories[0].name]/[title]';
 
             const resolvedPath = service.resolvePattern(uid as any, entity, pattern);
 
             expect(resolvedPath).toBe('/tech/my-article');
         });
 
+        it('should resolve pattern with many-to-many relation using specific index', () => {
+            const uid = 'api::article.article';
+            const entity = {
+                title: 'My Article',
+                categories: [
+                    { name: 'Tech' },
+                    { name: 'News' },
+                ],
+            };
+            const pattern = '/[categories[1].name]/[title]';
+
+            const resolvedPath = service.resolvePattern(uid as any, entity, pattern);
+
+            expect(resolvedPath).toBe('/news/my-article');
+        });
+
         it('should handle empty many-to-many relation', () => {
             const uid = 'api::article.article';
             const entity = {
                 title: 'My Article',
                 categories: [],
             };
-            const pattern = '/[categories.name]/[title]';
+            const pattern = '/[categories[0].name]/[title]';
 
             const resolvedPath = service.resolvePattern(uid as any, entity, pattern);
 

packages/core/server/services/url-pattern.ts

@@ -63,7 +63,11 @@ const customServices = () => ({
 
                     typedEntries(relation.attributes).forEach(([subFieldName, subField]) => {
                         if (subField.type === fieldType || subFieldName === fieldType) {
-                            fields.push(`${fieldName}.${subFieldName}`);
+                            if (field.relation.endsWith('ToMany')) {
+                                fields.push(`${fieldName}[0].${subFieldName}`);
+                            } else {
+                                fields.push(`${fieldName}.${subFieldName}`);
+                            }
                         }
                     });
                 } else if (
@@ -105,7 +109,7 @@ const customServices = () => ({
      * @returns {string[]} The extracted fields.
      */
     getFieldsFromPattern: (pattern: string): string[] => {
-        const fields = pattern.match(/[[\w\d.]+]/g); // Get all substrings between [] as array.
+        const fields = pattern.match(/\[.*?\]/g);
 
         if (!fields) {
             return [];
@@ -130,7 +134,7 @@ const customServices = () => ({
         fields = fields.filter((field) => field);
 
         // For fields containing dots, extract the first part (relation)
-        const relations = fields.filter((field) => field.includes('.')).map((field) => field.split('.')[0]);
+        const relations = fields.filter((field) => field.includes('.')).map((field) => field.split('.')[0].replace(/\[\d+\]/, ''));
 
         return relations;
     },
@@ -171,6 +175,17 @@ const customServices = () => ({
                 } else if (!relationalField) {
                     const fieldValue = slugify(String(entity[field]));
                     resolvedPattern = resolvedPattern.replace(`[${field}]`, fieldValue || '');
+                } else if (relationalField[0].match(/\[\d+\]/)) {
+                    const relationName = relationalField[0].split('[')[0];
+                    const index = parseInt(relationalField[0].split('[')[1].split(']')[0], 10);
+
+                    if (Array.isArray(entity[relationName]) && entity[relationName][index]) {
+                        const relation = entity[relationName][index];
+                        const fieldValue = slugify(String(relation[relationalField[1]]));
+                        resolvedPattern = resolvedPattern.replace(`[${field}]`, fieldValue || '');
+                    } else {
+                        resolvedPattern = resolvedPattern.replace(`[${field}]`, '');
+                    }
                 } else if (Array.isArray(entity[relationalField[0]])) {
                     // If the relation is a one-to-many or many-to-many, we use the first one.
                     const relation = entity[relationalField[0]][0];