@simtlix/simfinity-js 1.9.0 → 2.0.0

package/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.
@@ -1072,13 +1188,13 @@ const OrderType = new GraphQLObjectType({
 
 ### Custom Validated Scalar Types
 
-Create custom scalar types with built-in validation:
+Create custom scalar types with built-in validation. The generated type names follow the pattern `{name}_{baseScalarTypeName}`:
 
 ```javascript
 const { GraphQLString, GraphQLInt } = require('graphql');
 const { createValidatedScalar } = require('@simtlix/simfinity-js');
 
-// Email scalar with validation
+// Email scalar with validation (generates type name: Email_String)
 const EmailScalar = createValidatedScalar(
   'Email',
   'A valid email address',
@@ -1091,7 +1207,7 @@ const EmailScalar = createValidatedScalar(
   }
 );
 
-// Positive integer scalar
+// Positive integer scalar (generates type name: PositiveInt_Int)
 const PositiveIntScalar = createValidatedScalar(
   'PositiveInt',
   'A positive integer',
@@ -1108,8 +1224,8 @@ const UserType = new GraphQLObjectType({
   name: 'User',
   fields: () => ({
     id: { type: GraphQLID },
-    email: { type: EmailScalar },
-    age: { type: PositiveIntScalar },
+    email: { type: EmailScalar }, // Type name: Email_String
+    age: { type: PositiveIntScalar }, // Type name: PositiveInt_Int
   }),
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-js",
-  "version": "1.9.0",
+  "version": "2.0.0",
   "description": "",
   "main": "src/index.js",
   "type": "module",
@@ -18,7 +18,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/simtlix/simfinity.git"
+    "url": "git+https://github.com/simtlix/simfinity.git"
   },
   "peerDependencies": {
     "graphql": "^16.11.0",

package/src/index.js

@@ -202,7 +202,7 @@ function createValidatedScalar(name, description, baseScalarType, validate) {
   const baseKind = kindMap[baseScalarType.name] || Kind.STRING;
 
   const scalar = new GraphQLScalarType({
-    name,
+    name: `${name}_${baseScalarType.name}`,
     description,
     serialize(value) {
       validate(value);
@@ -214,7 +214,7 @@ function createValidatedScalar(name, description, baseScalarType, validate) {
     },
     parseLiteral(ast, variables) {
       if (ast.kind !== baseKind) {
-        throw new Error(`${name} must be a ${baseScalarType.name}`);
+        throw new Error(`${name}_${baseScalarType.name} must be a ${baseScalarType.name}`);
       }
       const value = baseScalarType.parseLiteral(ast, variables);
       validate(value);
@@ -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;
+}

package/tests/scalar-naming.test.js

@@ -0,0 +1,125 @@
+import {
+  describe, test, expect,
+} from 'vitest';
+import { GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID } from 'graphql';
+import { createValidatedScalar } from '../src/index.js';
+
+describe('Validated Scalar Naming Convention', () => {
+  test('should generate correct type names with base scalar type suffix', () => {
+    const EmailScalar = createValidatedScalar(
+      'Email',
+      'A valid email address',
+      GraphQLString,
+      (value) => {
+        if (!value.includes('@')) {
+          throw new Error('Invalid email format');
+        }
+      },
+    );
+
+    const EpisodeNumberScalar = createValidatedScalar(
+      'EpisodeNumber',
+      'A valid episode number',
+      GraphQLInt,
+      (value) => {
+        if (value <= 0) {
+          throw new Error('Episode number must be positive');
+        }
+      },
+    );
+
+    const RatingScalar = createValidatedScalar(
+      'Rating',
+      'A valid rating between 0 and 10',
+      GraphQLFloat,
+      (value) => {
+        if (value < 0 || value > 10) {
+          throw new Error('Rating must be between 0 and 10');
+        }
+      },
+    );
+
+    const IsActiveScalar = createValidatedScalar(
+      'IsActive',
+      'A boolean indicating if something is active',
+      GraphQLBoolean,
+      (value) => {
+        // Boolean validation is usually not needed, but this is for testing
+        if (typeof value !== 'boolean') {
+          throw new Error('Must be a boolean value');
+        }
+      },
+    );
+
+    const CustomIdScalar = createValidatedScalar(
+      'CustomId',
+      'A custom ID with specific format',
+      GraphQLID,
+      (value) => {
+        if (!value.startsWith('CUST_')) {
+          throw new Error('Custom ID must start with CUST_');
+        }
+      },
+    );
+
+    // Test the naming convention
+    expect(EmailScalar.name).toBe('Email_String');
+    expect(EpisodeNumberScalar.name).toBe('EpisodeNumber_Int');
+    expect(RatingScalar.name).toBe('Rating_Float');
+    expect(IsActiveScalar.name).toBe('IsActive_Boolean');
+    expect(CustomIdScalar.name).toBe('CustomId_ID');
+  });
+
+  test('should maintain baseScalarType property', () => {
+    const EmailScalar = createValidatedScalar(
+      'Email',
+      'A valid email address',
+      GraphQLString,
+      (value) => {
+        if (!value.includes('@')) {
+          throw new Error('Invalid email format');
+        }
+      },
+    );
+
+    expect(EmailScalar.baseScalarType).toBe(GraphQLString);
+    expect(EmailScalar.name).toBe('Email_String');
+  });
+
+  test('should work with validation functions', () => {
+    const EpisodeNumberScalar = createValidatedScalar(
+      'EpisodeNumber',
+      'A valid episode number',
+      GraphQLInt,
+      (value) => {
+        if (value <= 0) {
+          throw new Error('Episode number must be positive');
+        }
+      },
+    );
+
+    // Test valid value
+    expect(() => EpisodeNumberScalar.serialize(5)).not.toThrow();
+    expect(EpisodeNumberScalar.serialize(5)).toBe(5);
+
+    // Test invalid value
+    expect(() => EpisodeNumberScalar.serialize(0)).toThrow('Episode number must be positive');
+    expect(() => EpisodeNumberScalar.serialize(-1)).toThrow('Episode number must be positive');
+  });
+
+  test('should generate error messages with correct type names', () => {
+    const EpisodeNumberScalar = createValidatedScalar(
+      'EpisodeNumber',
+      'A valid episode number',
+      GraphQLInt,
+      (value) => {
+        if (value <= 0) {
+          throw new Error('Episode number must be positive');
+        }
+      },
+    );
+
+    // The error message should include the full type name
+    expect(() => EpisodeNumberScalar.serialize(0)).toThrow('Episode number must be positive');
+  });
+}); 

package/tests/validated-scalar.test.js

@@ -70,7 +70,7 @@ describe('Custom Validated Scalar Types', () => {
   describe('createValidatedScalar function', () => {
     test('should create a valid scalar type with baseScalarType property', () => {
       expect(EmailScalar).toBeDefined();
-      expect(EmailScalar.name).toBe('Email');
+      expect(EmailScalar.name).toBe('Email_String');
       expect(EmailScalar.baseScalarType).toBe(GraphQLString);
       expect(EmailScalar.serialize).toBeDefined();
       expect(EmailScalar.parseValue).toBeDefined();