feat: Add collection field filtering support

- Add support for filtering collection fields (one-to-many relationships) using the same query format as main queries
- Implement formatArgs function for proper GraphQL argument formatting
- Add comprehensive documentation for collection field filtering feature
- Update version to 2.0.0

This major version bump introduces the ability to filter related objects directly within GraphQL queries, providing more powerful and flexible querying capabilities.

Author: Claudio Gonzalez

README.md

@@ -204,6 +204,122 @@ query {
 - `NIN` - Not in array
 - `BTW` - Between two values
 
+### Collection Field Filtering
+
+Simfinity.js now supports filtering collection fields (one-to-many relationships) using the same powerful query format. This allows you to filter related objects directly within your GraphQL queries.
+
+#### Basic Collection Filtering
+
+Filter collection fields using the same operators and format as main queries:
+
+```graphql
+query {
+  series {
+    seasons(number: { operator: EQ, value: 1 }) {
+      number
+      id
+      year
+    }
+  }
+}
+```
+
+#### Advanced Collection Filtering
+
+You can use complex filtering with nested object properties:
+
+```graphql
+query {
+  series {
+    seasons(
+      year: { operator: GTE, value: 2020 }
+      episodes: {
+        terms: [
+          {
+            path: "name",
+            operator: LIKE,
+            value: "Pilot"
+          }
+        ]
+      }
+    ) {
+      number
+      year
+      episodes {
+        name
+        date
+      }
+    }
+  }
+}
+```
+
+#### Collection Filtering with Multiple Conditions
+
+Combine multiple filter conditions for collection fields:
+
+```graphql
+query {
+  series {
+    seasons(
+      number: { operator: GT, value: 1 }
+      year: { operator: BTW, value: [2015, 2023] }
+    ) {
+      number
+      year
+      state
+    }
+  }
+}
+```
+
+#### Nested Collection Filtering
+
+Filter deeply nested collections using dot notation:
+
+```graphql
+query {
+  series {
+    seasons(
+      episodes: {
+        terms: [
+          {
+            path: "name",
+            operator: LIKE,
+            value: "Final"
+          }
+        ]
+      }
+    ) {
+      number
+      episodes {
+        name
+        date
+      }
+    }
+  }
+}
+```
+
+#### Collection Filtering with Array Operations
+
+Use array operations for collection fields:
+
+```graphql
+query {
+  series {
+    seasons(
+      categories: { operator: IN, value: ["Drama", "Crime"] }
+    ) {
+      number
+      categories
+    }
+  }
+}
+```
+
+**Note**: Collection field filtering uses the exact same format as main query filtering, ensuring consistency across your GraphQL API. All available operators (`EQ`, `NE`, `GT`, `LT`, `GTE`, `LTE`, `LIKE`, `IN`, `NIN`, `BTW`) work with collection fields.
+
 ## 🔧 Middlewares
 
 Middlewares provide a powerful way to intercept and process all GraphQL operations before they execute. Use them for cross-cutting concerns like authentication, logging, validation, and performance monitoring.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-js",
-  "version": "1.9.1",
+  "version": "2.0.0",
   "description": "",
   "main": "src/index.js",
   "type": "module",

simtlix-simfinity-js-1.9.1.tgz

@@ -1516,37 +1516,7 @@ const buildRootQuery = (name, includedTypes) => {
 
         const argTypes = type.gqltype.getFields();
 
-        const argsObject = {};
-
-        for (const [fieldEntryName, fieldEntry] of Object.entries(argTypes)) {
-          argsObject[fieldEntryName] = {};
-
-          if (fieldEntry.type instanceof GraphQLScalarType
-            || isNonNullOfType(fieldEntry.type, GraphQLScalarType)
-            || fieldEntry.type instanceof GraphQLEnumType
-            || isNonNullOfType(fieldEntry.type, GraphQLEnumType)) {
-            argsObject[fieldEntryName].type = QLFilter;
-          } else if (fieldEntry.type instanceof GraphQLObjectType
-            || isNonNullOfType(fieldEntry.type, GraphQLObjectType)) {
-            argsObject[fieldEntryName].type = QLTypeFilterExpression;
-          } else if (fieldEntry.type instanceof GraphQLList) {
-            const listOfType = fieldEntry.type.ofType;
-            if (listOfType instanceof GraphQLScalarType
-              || isNonNullOfType(listOfType, GraphQLScalarType)
-              || listOfType instanceof GraphQLEnumType
-              || isNonNullOfType(listOfType, GraphQLEnumType)) {
-              argsObject[fieldEntryName].type = QLFilter;
-            } else {
-              argsObject[fieldEntryName].type = QLTypeFilterExpression;
-            }
-          }
-        }
-
-        argsObject.pagination = {};
-        argsObject.pagination.type = QLPagination;
-
-        argsObject.sort = {};
-        argsObject.sort.type = QLSortExpression;
+        const argsObject = createArgsForQuery(argTypes);
 
         rootQueryArgs.fields[type.listEntitiesEndpointName] = {
           type: new GraphQLList(type.gqltype),
@@ -1656,18 +1626,39 @@ const autoGenerateResolvers = (gqltype) => {
         if (!relation.embedded) {
           if (fieldEntry.type instanceof GraphQLList) {
             // Collection field - generate resolve for one-to-many relationship
+            //This is a one-to-many resolver that will return a list of related objects. Also this one allows to filter the related objects as is in the find endpoint.
             const relatedType = fieldEntry.type.ofType;
             const connectionField = relation.connectionField || fieldName;
+            const relatedTypeInfo = typesDict.types[relatedType.name];
+            const argsObject = createArgsForQuery(relatedTypeInfo.gqltype.getFields());
+            
+            delete argsObject[connectionField];
+            const argsArray = Object.entries(argsObject);
+            
 
-            fieldEntry.resolve = (parent) => {
+            const graphqlArgs = formatArgs(argsArray);
+
+            fieldEntry.args = graphqlArgs;
+
+            fieldEntry.resolve = async (parent, args) => {
               // Lazy lookup of the related model
-              const relatedTypeInfo = typesDict.types[relatedType.name];
+              
               if (!relatedTypeInfo || !relatedTypeInfo.model) {
                 throw new Error(`Related type ${relatedType.name} not found or not connected. Make sure it's connected with simfinity.connect() or simfinity.addNoEndpointType().`);
               }
-              const query = {};
-              query[connectionField] = parent.id || parent._id;
-              return relatedTypeInfo.model.find(query);
+              
+              args[connectionField] = {
+                  terms: [{
+                  path: 'id',
+                  operator: 'EQ',
+                  value: parent.id || parent._id,
+                }],
+              };
+            
+
+              const aggregateClauses = await buildQuery(args, relatedTypeInfo.gqltype);
+              
+              return await relatedTypeInfo.model.aggregate(aggregateClauses);
             };
           } else if (fieldEntry.type instanceof GraphQLObjectType
                      || (fieldEntry.type instanceof GraphQLNonNull && fieldEntry.type.ofType instanceof GraphQLObjectType)) {
@@ -1741,3 +1732,50 @@ export const addNoEndpointType = (gqltype) => {
 };
 
 export { createValidatedScalar };
+
+const createArgsForQuery = (argTypes) => {
+    const argsObject = {};
+
+    for (const [fieldEntryName, fieldEntry] of Object.entries(argTypes)) {
+      argsObject[fieldEntryName] = {};
+
+      if (fieldEntry.type instanceof GraphQLScalarType
+        || isNonNullOfType(fieldEntry.type, GraphQLScalarType)
+        || fieldEntry.type instanceof GraphQLEnumType
+        || isNonNullOfType(fieldEntry.type, GraphQLEnumType)) {
+        argsObject[fieldEntryName].type = QLFilter;
+      } else if (fieldEntry.type instanceof GraphQLObjectType
+        || isNonNullOfType(fieldEntry.type, GraphQLObjectType)) {
+        argsObject[fieldEntryName].type = QLTypeFilterExpression;
+      } else if (fieldEntry.type instanceof GraphQLList) {
+        const listOfType = fieldEntry.type.ofType;
+        if (listOfType instanceof GraphQLScalarType
+          || isNonNullOfType(listOfType, GraphQLScalarType)
+          || listOfType instanceof GraphQLEnumType
+          || isNonNullOfType(listOfType, GraphQLEnumType)) {
+          argsObject[fieldEntryName].type = QLFilter;
+        } else {
+          argsObject[fieldEntryName].type = QLTypeFilterExpression;
+        }
+      }
+    }
+
+    argsObject.pagination = {};
+    argsObject.pagination.type = QLPagination;
+
+    argsObject.sort = {};
+    argsObject.sort.type = QLSortExpression;
+    return argsObject;
+};
+
+function formatArgs(argsArray) {
+  const graphqlArgs = [];
+  for (const [key, value] of argsArray) {
+    const item = {
+      name: key,
+      type: value.type,
+    };
+    graphqlArgs.push(item);
+  }
+  return graphqlArgs;
+}