@simtlix/simfinity-js 1.7.0 → 1.9.0

package/README.md

@@ -8,6 +8,7 @@ A powerful Node.js framework that automatically generates GraphQL schemas from y
 - **MongoDB Integration**: Seamless translation between GraphQL and MongoDB
 - **Powerful Querying**: Any query that can be executed in MongoDB can be executed in GraphQL
 - **Auto-Generated Resolvers**: Automatically generates resolve methods for relationship fields
+- **Automatic Index Creation**: Automatically creates MongoDB indexes for all ObjectId fields, including nested embedded objects and relationship fields
 - **Business Logic**: Implement business logic and domain validations declaratively
 - **State Machines**: Built-in support for declarative state machine workflows
 - **Lifecycle Hooks**: Controller methods for granular control over operations

package/README_INDEX_EXAMPLE.md

@@ -0,0 +1,252 @@
+# Automatic ObjectId Index Creation
+
+This feature automatically creates MongoDB indexes for all ObjectId fields when models are generated, including nested embedded objects.
+
+## How it works
+
+When you define GraphQL types with ObjectId fields (GraphQLID), the system will automatically:
+
+1. Analyze the schema definition to find all ObjectId fields
+2. Create indexes for each ObjectId field found
+3. Handle nested embedded objects recursively
+4. Create indexes for arrays of embedded objects
+5. Create indexes for relationship fields (foreign keys between types)
+
+## Examples
+
+### Simple ObjectId fields
+
+```javascript
+import { GraphQLObjectType, GraphQLString, GraphQLID } from 'graphql';
+import * as simfinity from '@simtlix/simfinity-js';
+
+const UserType = new GraphQLObjectType({
+  name: 'User',
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    email: { type: GraphQLString },
+    managerId: { type: GraphQLID }, // This will get an index
+  }),
+});
+
+simfinity.connect(null, UserType, 'user', 'users');
+simfinity.createSchema();
+```
+
+This will create indexes for:
+- `id` field
+- `managerId` field
+
+### Relationship fields (non-embedded)
+
+```javascript
+const DepartmentType = new GraphQLObjectType({
+  name: 'Department',
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+  }),
+});
+
+const UserType = new GraphQLObjectType({
+  name: 'User',
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    email: { type: GraphQLString },
+    department: { 
+      type: DepartmentType,
+      extensions: {
+        relation: { embedded: false } // or omit this line (default is false)
+      }
+    },
+  }),
+});
+
+// Register both types
+simfinity.connect(null, DepartmentType, 'department', 'departments');
+simfinity.connect(null, UserType, 'user', 'users');
+simfinity.createSchema();
+```
+
+This will create indexes for:
+- `id` field (in both User and Department)
+- `department` field (the foreign key field that references Department)
+
+### One-to-Many relationships
+
+```javascript
+const OrderType = new GraphQLObjectType({
+  name: 'Order',
+  fields: () => ({
+    id: { type: GraphQLID },
+    orderNumber: { type: GraphQLString },
+    customerId: { type: GraphQLID }, // This will get an index
+    items: { 
+      type: new GraphQLList(OrderItemType),
+      extensions: {
+        relation: { embedded: false }
+      }
+    },
+  }),
+});
+
+const OrderItemType = new GraphQLObjectType({
+  name: 'OrderItem',
+  fields: () => ({
+    id: { type: GraphQLID },
+    productId: { type: GraphQLID }, // This will get an index
+    quantity: { type: GraphQLString },
+    orderId: { type: GraphQLID }, // This will get an index (foreign key)
+  }),
+});
+
+// Register both types
+simfinity.connect(null, OrderItemType, 'orderItem', 'orderItems');
+simfinity.connect(null, OrderType, 'order', 'orders');
+simfinity.createSchema();
+```
+
+This will create indexes for:
+- `id` field (in both Order and OrderItem)
+- `customerId` field (in Order)
+- `productId` field (in OrderItem)
+- `orderId` field (in OrderItem - the foreign key that references Order)
+
+### Embedded objects with ObjectId
+
+```javascript
+const AddressType = new GraphQLObjectType({
+  name: 'Address',
+  fields: () => ({
+    street: { type: GraphQLString },
+    city: { type: GraphQLString },
+    countryId: { type: GraphQLID }, // This will get an index
+  }),
+});
+
+const UserType = new GraphQLObjectType({
+  name: 'User',
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    address: { 
+      type: AddressType,
+      extensions: {
+        relation: { embedded: true }
+      }
+    },
+  }),
+});
+
+// Register the embedded type
+simfinity.addNoEndpointType(AddressType);
+simfinity.connect(null, UserType, 'user', 'users');
+simfinity.createSchema();
+```
+
+This will create indexes for:
+- `id` field
+- `countryId` field (from AddressType)
+- `address.countryId` field (embedded path)
+
+### Nested embedded objects
+
+```javascript
+const CityType = new GraphQLObjectType({
+  name: 'City',
+  fields: () => ({
+    name: { type: GraphQLString },
+    stateId: { type: GraphQLID }, // This will get an index
+  }),
+});
+
+const AddressType = new GraphQLObjectType({
+  name: 'Address',
+  fields: () => ({
+    street: { type: GraphQLString },
+    city: { 
+      type: CityType,
+      extensions: {
+        relation: { embedded: true }
+      }
+    },
+  }),
+});
+
+const UserType = new GraphQLObjectType({
+  name: 'User',
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    address: { 
+      type: AddressType,
+      extensions: {
+        relation: { embedded: true }
+      }
+    },
+  }),
+});
+
+// Register the embedded types
+simfinity.addNoEndpointType(CityType);
+simfinity.addNoEndpointType(AddressType);
+simfinity.connect(null, UserType, 'user', 'users');
+simfinity.createSchema();
+```
+
+This will create indexes for:
+- `id` field
+- `stateId` field (from CityType)
+- `city.stateId` field (from AddressType)
+- `address.city.stateId` field (nested embedded path)
+
+### Arrays of embedded objects
+
+```javascript
+const OrderItemType = new GraphQLObjectType({
+  name: 'OrderItem',
+  fields: () => ({
+    productId: { type: GraphQLID }, // This will get an index
+    quantity: { type: GraphQLString },
+  }),
+});
+
+const OrderType = new GraphQLObjectType({
+  name: 'Order',
+  fields: () => ({
+    id: { type: GraphQLID },
+    customerId: { type: GraphQLID },
+    items: { 
+      type: new GraphQLList(OrderItemType),
+      extensions: {
+        relation: { embedded: true }
+      }
+    },
+  }),
+});
+
+// Register the embedded type
+simfinity.addNoEndpointType(OrderItemType);
+simfinity.connect(null, OrderType, 'order', 'orders');
+simfinity.createSchema();
+```
+
+This will create indexes for:
+- `id` field
+- `customerId` field
+- `productId` field (from OrderItemType)
+- `items.productId` field (array embedded path)
+
+## Benefits
+
+1. **Automatic Performance Optimization**: ObjectId fields are automatically indexed for better query performance
+2. **Relationship Optimization**: Foreign key fields are automatically indexed for efficient joins and lookups
+3. **No Manual Configuration**: No need to manually specify which fields should be indexed
+4. **Handles Complex Schemas**: Works with nested embedded objects and arrays
+5. **Consistent**: All ObjectId fields get the same treatment regardless of their location in the schema
+
+## Technical Details
+
+The system uses the `mongoose.Schema` constructor to create schemas and then calls `schema.index()` for each ObjectId field found. The index creation happens during model generation, so it's transparent to the application code. 

package/package.json

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

package/src/index.js

@@ -1003,8 +1003,56 @@ const generateSchemaDefinition = (gqlType) => {
   return schemaArg;
 };
 
+const findObjectIdFields = (schemaDefinition, parentPath = '') => {
+  const objectIdFields = [];
+  
+  for (const [fieldName, fieldDefinition] of Object.entries(schemaDefinition)) {
+    const currentPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
+    
+    if (fieldDefinition === mongoose.Schema.Types.ObjectId) {
+      // Direct ObjectId field
+      objectIdFields.push(currentPath);
+    } else if (typeof fieldDefinition === 'object' && fieldDefinition !== null) {
+      if (Array.isArray(fieldDefinition)) {
+        // Array field - check if it's an array of objects
+        const arrayElement = fieldDefinition[0];
+        if (typeof arrayElement === 'object' && arrayElement !== null) {
+          // Array of embedded objects - recursively check for ObjectId fields
+          const nestedObjectIdFields = findObjectIdFields(arrayElement, currentPath);
+          objectIdFields.push(...nestedObjectIdFields);
+        }
+      } else if (fieldDefinition.type === mongoose.Schema.Types.ObjectId) {
+        // Object with ObjectId type
+        objectIdFields.push(currentPath);
+      } else if (typeof fieldDefinition === 'object' && !fieldDefinition.type) {
+        // Embedded object - recursively check for ObjectId fields
+        const nestedObjectIdFields = findObjectIdFields(fieldDefinition, currentPath);
+        objectIdFields.push(...nestedObjectIdFields);
+      }
+    }
+  }
+  
+  return objectIdFields;
+};
+
+const createSchemaWithIndexes = (schemaDefinition) => {
+  const schema = new mongoose.Schema(schemaDefinition);
+  
+  // Find all ObjectId fields in the schema
+  const objectIdFields = findObjectIdFields(schemaDefinition);
+  
+  // Create indexes for all ObjectId fields
+  objectIdFields.forEach(fieldPath => {
+    schema.index({ [fieldPath]: 1 });
+  });
+  
+  return schema;
+};
+
 const generateModel = (gqlType, onModelCreated) => {
-  const model = mongoose.model(gqlType.name, generateSchemaDefinition(gqlType), gqlType.name);
+  const schemaDefinition = generateSchemaDefinition(gqlType);
+  const schema = createSchemaWithIndexes(schemaDefinition);
+  const model = mongoose.model(gqlType.name, schema, gqlType.name);
   if (onModelCreated) {
     onModelCreated(model);
   }
@@ -1015,7 +1063,9 @@ const generateModel = (gqlType, onModelCreated) => {
 };
 
 const generateModelWithoutCollection = (gqlType, onModelCreated) => {
-  const model = mongoose.model(gqlType.name, generateSchemaDefinition(gqlType), gqlType.name);
+  const schemaDefinition = generateSchemaDefinition(gqlType);
+  const schema = createSchemaWithIndexes(schemaDefinition);
+  const model = mongoose.model(gqlType.name, schema, gqlType.name);
   if (onModelCreated) {
     onModelCreated(model);
   }
@@ -1537,6 +1587,26 @@ we will allow users to use when they are making request. */
 export const createSchema = (includedQueryTypes,
   includedMutationTypes, includedCustomMutations) => {
   
+  // Generate models for all registered types now that all types are available
+  Object.values(typesDict.types).forEach(typeInfo => {
+    if (typeInfo.gqltype && !typeInfo.model) {
+      if (typeInfo.endpoint) {
+        // Generate model with collection for endpoint types (types registered with connect)
+        typeInfo.model = generateModel(typeInfo.gqltype, typeInfo.onModelCreated);
+      } else if (typeInfo.needsModel) {
+        // Generate model without collection for no-endpoint types that need models (addNoEndpointType)
+        typeInfo.model = generateModelWithoutCollection(typeInfo.gqltype, null);
+      }
+    }
+  });
+
+  // Also update the typesDictForUpdate with the generated models
+  Object.keys(typesDict.types).forEach(typeName => {
+    if (typesDictForUpdate.types[typeName]) {
+      typesDictForUpdate.types[typeName].model = typesDict.types[typeName].model;
+    }
+  });
+
   // Auto-generate resolvers for all registered types now that all types are available
   Object.values(typesDict.types).forEach(typeInfo => {
     if (typeInfo.gqltype) {
@@ -1628,13 +1698,14 @@ export const connect = (model, gqltype, simpleEntityEndpointName,
     gqltype,
   };
   typesDict.types[gqltype.name] = {
-    model: model || generateModel(gqltype, onModelCreated),
+    model: model, // Will be generated later in createSchema if not provided
     gqltype,
     simpleEntityEndpointName,
     listEntitiesEndpointName,
     endpoint: true,
     controller,
     stateMachine,
+    onModelCreated, // Store the callback for later use
   };
 
   typesDictForUpdate.types[gqltype.name] = { ...typesDict.types[gqltype.name] };
@@ -1661,8 +1732,9 @@ export const addNoEndpointType = (gqltype) => {
   typesDict.types[gqltype.name] = {
     gqltype,
     endpoint: false,
-    // Generate model if needed for relationships, but don't create collection
-    model: needsModel ? generateModelWithoutCollection(gqltype, null) : null,
+    // Model will be generated later in createSchema if needed
+    model: null,
+    needsModel, // Store whether this type needs a model
   };
 
   typesDictForUpdate.types[gqltype.name] = { ...typesDict.types[gqltype.name] };

package/tests/objectid-indexes.test.js

@@ -0,0 +1,215 @@
+import {
+  describe, test, expect, beforeEach, afterEach, vi,
+} from 'vitest';
+import mongoose from 'mongoose';
+import { GraphQLObjectType, GraphQLString, GraphQLID, GraphQLList } from 'graphql';
+import * as simfinity from '../src/index.js';
+
+describe('ObjectId Index Creation', () => {
+  let indexSpy;
+
+  beforeEach(() => {
+    // Spy on the index method of mongoose Schema
+    indexSpy = vi.spyOn(mongoose.Schema.prototype, 'index').mockImplementation(() => {});
+    // Prevent collection creation to avoid database connection issues
+    simfinity.preventCreatingCollection(true);
+  });
+
+  afterEach(() => {
+    // Restore the original implementation
+    indexSpy.mockRestore();
+  });
+
+  test('should create index for direct ObjectId field', () => {
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeWithObjectId',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+        userId: { type: GraphQLID },
+      }),
+    });
+
+    simfinity.connect(null, TestType, 'testTypeWithObjectId', 'testTypesWithObjectId');
+    simfinity.createSchema();
+
+    // Should create indexes for both id and userId fields
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
+    expect(indexSpy).toHaveBeenCalledWith({ userId: 1 });
+    expect(indexSpy).toHaveBeenCalledTimes(2);
+  });
+
+  test('should create index for embedded ObjectId field', () => {
+    const EmbeddedType = new GraphQLObjectType({
+      name: 'EmbeddedType',
+      fields: () => ({
+        embeddedId: { type: GraphQLID },
+        embeddedName: { type: GraphQLString },
+      }),
+    });
+
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeWithEmbedded',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+        embedded: { 
+          type: EmbeddedType,
+          extensions: {
+            relation: { embedded: true },
+          },
+        },
+      }),
+    });
+
+    // Register the embedded type first
+    simfinity.addNoEndpointType(EmbeddedType);
+    simfinity.connect(null, TestType, 'testTypeWithEmbedded', 'testTypesWithEmbedded');
+    simfinity.createSchema();
+
+    // Should create indexes for id and embedded.embeddedId fields
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
+    expect(indexSpy).toHaveBeenCalledWith({ 'embedded.embeddedId': 1 });
+    expect(indexSpy).toHaveBeenCalledTimes(2);
+  });
+
+  test('should create index for nested embedded ObjectId field', () => {
+    const DeepEmbeddedType = new GraphQLObjectType({
+      name: 'DeepEmbeddedType',
+      fields: () => ({
+        deepId: { type: GraphQLID },
+        deepName: { type: GraphQLString },
+      }),
+    });
+
+    const EmbeddedType = new GraphQLObjectType({
+      name: 'EmbeddedTypeWithDeep',
+      fields: () => ({
+        embeddedId: { type: GraphQLID },
+        embeddedName: { type: GraphQLString },
+        deep: { 
+          type: DeepEmbeddedType,
+          extensions: {
+            relation: { embedded: true },
+          },
+        },
+      }),
+    });
+
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeWithNestedEmbedded',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+        embedded: { 
+          type: EmbeddedType,
+          extensions: {
+            relation: { embedded: true },
+          },
+        },
+      }),
+    });
+
+    // Register the embedded types first
+    simfinity.addNoEndpointType(DeepEmbeddedType);
+    simfinity.addNoEndpointType(EmbeddedType);
+    simfinity.connect(null, TestType, 'testTypeWithNestedEmbedded', 'testTypesWithNestedEmbedded');
+    simfinity.createSchema();
+
+    // Should create indexes for all ObjectId fields at all levels
+    expect(indexSpy).toHaveBeenCalledWith({ embeddedId: 1 }); // EmbeddedType
+    expect(indexSpy).toHaveBeenCalledWith({ 'deep.deepId': 1 }); // DeepEmbeddedType
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 }); // TestType
+    expect(indexSpy).toHaveBeenCalledWith({ 'embedded.embeddedId': 1 }); // embedded field in TestType
+    expect(indexSpy).toHaveBeenCalledWith({ 'embedded.deep.deepId': 1 }); // nested embedded field in TestType
+    expect(indexSpy).toHaveBeenCalledTimes(5);
+  });
+
+  test('should create index for array of embedded objects with ObjectId', () => {
+    const EmbeddedType = new GraphQLObjectType({
+      name: 'EmbeddedTypeForArray',
+      fields: () => ({
+        embeddedId: { type: GraphQLID },
+        embeddedName: { type: GraphQLString },
+      }),
+    });
+
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeWithEmbeddedArray',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+        embeddedArray: { 
+          type: new GraphQLList(EmbeddedType),
+          extensions: {
+            relation: { embedded: true },
+          },
+        },
+      }),
+    });
+
+    // Register the embedded type first
+    simfinity.addNoEndpointType(EmbeddedType);
+    simfinity.connect(null, TestType, 'testTypeWithEmbeddedArray', 'testTypesWithEmbeddedArray');
+    simfinity.createSchema();
+
+    // Should create indexes for id and embeddedArray.embeddedId fields
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
+    expect(indexSpy).toHaveBeenCalledWith({ 'embeddedArray.embeddedId': 1 });
+    expect(indexSpy).toHaveBeenCalledTimes(2);
+  });
+
+  test('should not create index for non-ObjectId fields', () => {
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeWithoutObjectId',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+        age: { type: GraphQLString },
+        active: { type: GraphQLString },
+      }),
+    });
+
+    simfinity.connect(null, TestType, 'testTypeWithoutObjectId', 'testTypesWithoutObjectId');
+    simfinity.createSchema();
+
+    // Should only create index for id field (ObjectId), not for other fields
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
+    expect(indexSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('should create index for relationship fields (non-embedded)', () => {
+    const DepartmentType = new GraphQLObjectType({
+      name: 'DepartmentType',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+      }),
+    });
+
+    const UserType = new GraphQLObjectType({
+      name: 'TestTypeWithRelationship',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+        department: { 
+          type: DepartmentType,
+          extensions: {
+            relation: { embedded: false },
+          },
+        },
+      }),
+    });
+
+    // Register both types
+    simfinity.connect(null, DepartmentType, 'department', 'departments');
+    simfinity.connect(null, UserType, 'testTypeWithRelationship', 'testTypesWithRelationship');
+    simfinity.createSchema();
+
+    // Should create indexes for id fields in both types and the relationship field
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 }); // DepartmentType
+    expect(indexSpy).toHaveBeenCalledWith({ id: 1 }); // UserType
+    expect(indexSpy).toHaveBeenCalledWith({ department: 1 }); // relationship field
+    expect(indexSpy).toHaveBeenCalledTimes(3);
+  });
+}); 

package/tests/prevent-collection-creation.test.js

@@ -28,6 +28,7 @@ describe('preventCreatingCollection option', () => {
     });
 
     simfinity.connect(null, TestType, 'testTypeDefault', 'testTypesDefault');
+    simfinity.createSchema(); // Models are now generated during schema creation
     expect(createCollectionSpy).toHaveBeenCalledTimes(1);
   });
 
@@ -43,6 +44,7 @@ describe('preventCreatingCollection option', () => {
     });
 
     simfinity.connect(null, TestType, 'testTypePrevent', 'testTypesPrevent');
+    simfinity.createSchema(); // Models are now generated during schema creation
     expect(createCollectionSpy).not.toHaveBeenCalled();
   });
 
@@ -59,6 +61,7 @@ describe('preventCreatingCollection option', () => {
     });
 
     simfinity.connect(null, TestType, 'testTypeAllow', 'testTypesAllow');
+    simfinity.createSchema(); // Models are now generated during schema creation
     expect(createCollectionSpy).toHaveBeenCalledTimes(1);
   });
 });

package/tests/validated-scalar.test.js

@@ -117,6 +117,7 @@ describe('Custom Validated Scalar Types', () => {
 
     beforeAll(() => {
       simfinity.connect(null, UserType, 'user', 'users');
+      simfinity.createSchema(); // Models are now generated during schema creation
       UserModel = simfinity.getModel(UserType);
     });
 
@@ -150,6 +151,7 @@ describe('Custom Validated Scalar Types', () => {
         }),
       });
       simfinity.connect(null, UserWithUniqueType, 'userWithUnique', 'usersWithUnique');
+      simfinity.createSchema(); // Models are now generated during schema creation
       const UserWithUniqueModel = simfinity.getModel(UserWithUniqueType);
       const schema = UserWithUniqueModel.schema.obj;