@simtlix/simfinity-js 1.1.0 → 1.3.0

package/src/index.js

@@ -7,12 +7,12 @@ const QLOperator = require('./const/QLOperator');
 const QLValue = require('./const/QLValue');
 const QLSort = require('./const/QLSort');
 
-mongoose.set('useFindAndModify', false);
+mongoose.set('strictQuery', false);
 
 const {
   GraphQLObjectType, GraphQLString, GraphQLID, GraphQLSchema, GraphQLList,
   GraphQLNonNull, GraphQLInputObjectType, GraphQLScalarType, __Field,
-  GraphQLInt, GraphQLEnumType, GraphQLBoolean, GraphQLFloat,
+  GraphQLInt, GraphQLEnumType, GraphQLBoolean, GraphQLFloat, Kind,
 } = graphql;
 
 // Adding 'extensions' field into instronspection query
@@ -93,6 +93,12 @@ module.exports.SimfinityError = SimfinityError;
 
 module.exports.InternalServerError = InternalServerError;
 
+let preventCollectionCreation = false;
+
+module.exports.preventCreatingCollection = (prevent) => {
+  preventCollectionCreation = !!prevent;
+};
+
 /* Schema defines data on the Graph like object types(book type), relation between
 these object types and describes how it can reach into the graph to interact with
 the data to retrieve or mutate the data */
@@ -159,26 +165,123 @@ const isNonNullOfTypeForNotScalar = (fieldEntryType, graphQLType) => {
   return isOfType;
 };
 
+const getEffectiveTypeName = (type) => {
+  if (type instanceof GraphQLScalarType && type.baseScalarType) {
+    return type.baseScalarType.name;
+  }
+  return type.name;
+};
+
 const isGraphQLisoDate = (typeName) => typeName === 'DateTime' || typeName === 'Date' || typeName === 'Time';
 
+function createValidatedScalar(name, description, baseScalarType, validate) {
+  if (!baseScalarType) {
+    throw new Error('baseScalarType is required');
+  }
+
+  // Validate that baseScalarType is a valid GraphQL scalar type
+  if (!(baseScalarType instanceof GraphQLScalarType)) {
+    throw new Error('baseScalarType must be a valid GraphQL scalar type');
+  }
+
+  // Check if it's one of the standard GraphQL scalar types
+  const validScalarTypes = [GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID];
+  const isValidStandardType = validScalarTypes.some((type) => baseScalarType === type);
+
+  if (!isValidStandardType && !baseScalarType.name) {
+    throw new Error('baseScalarType must be a standard GraphQL scalar type or a custom scalar with a valid name');
+  }
+
+  const kindMap = {
+    String: Kind.STRING,
+    Int: Kind.INT,
+    Float: Kind.FLOAT,
+    Boolean: Kind.BOOLEAN,
+    ID: Kind.STRING, // IDs are represented as strings in AST
+  };
+
+  // Try to infer the kind from the baseScalarType name
+  const baseKind = kindMap[baseScalarType.name] || Kind.STRING;
+
+  const scalar = new GraphQLScalarType({
+    name,
+    description,
+    serialize(value) {
+      validate(value);
+      return baseScalarType.serialize(value);
+    },
+    parseValue(value) {
+      validate(value);
+      return baseScalarType.parseValue(value);
+    },
+    parseLiteral(ast, variables) {
+      if (ast.kind !== baseKind) {
+        throw new Error(`${name} must be a ${baseScalarType.name}`);
+      }
+      const value = baseScalarType.parseLiteral(ast, variables);
+      validate(value);
+      return value;
+    },
+  });
+
+  scalar.baseScalarType = baseScalarType;
+  return scalar;
+}
+
+/**
+ * Creates a new GraphQLInputObjectType with a field excluded.
+ * @param {string} inputNamePrefix - The prefix for the input type name.
+ * @param {GraphQLInputObjectType} originalType - The original input type.
+ * @param {string} fieldToExclude - The name of the field to exclude.
+ * @returns {GraphQLInputObjectType} A new input type without the specified field.
+ */
+const createTypeWithExcludedField = (inputNamePrefix, originalType, fieldToExclude) => {
+  const originalFields = originalType.getFields();
+  const newFields = Object.fromEntries(
+    Object.entries(originalFields).filter(([fieldName]) => fieldName !== fieldToExclude),
+  );
+
+  return new GraphQLInputObjectType({
+    name: `${inputNamePrefix}${originalType.name}For${fieldToExclude.charAt(0).toUpperCase() + fieldToExclude.slice(1)}`,
+    fields: newFields,
+  });
+};
+
 const createOneToManyInputType = (inputNamePrefix, fieldEntryName,
-  inputType, updateInputType) => new GraphQLInputObjectType({
-  name: `OneToMany${inputNamePrefix}${fieldEntryName}`,
-  fields: () => ({
-    added: { type: new GraphQLList(inputType) },
-    updated: { type: new GraphQLList(updateInputType) },
-    deleted: { type: new GraphQLList(GraphQLID) },
-  }),
-});
+  inputType, updateInputType, connectionField) => {
+  let inputTypeForAdd = inputType;
+
+  // If a gqltype is provided, create a new input type for 'added'
+  // that excludes the field named after the gqltype.
+  if (connectionField) {
+    const fieldToExclude = connectionField;
+    inputTypeForAdd = createTypeWithExcludedField(inputNamePrefix, inputType, fieldToExclude);
+  }
 
-const graphQLListInputType = (dict, fieldEntry, fieldEntryName, inputNamePrefix) => {
+  return new GraphQLInputObjectType({
+    name: `OneToMany${inputNamePrefix}${fieldEntryName}`,
+    fields: () => ({
+      added: {
+        type: new GraphQLList(inputTypeForAdd),
+      },
+      updated: {
+        type: new GraphQLList(updateInputType),
+      },
+      deleted: {
+        type: new GraphQLList(GraphQLID),
+      },
+    }),
+  });
+};
+
+const graphQLListInputType = (dict, fieldEntry, fieldEntryName, inputNamePrefix, connectionField) => {
   const { ofType } = fieldEntry.type;
 
   if (ofType instanceof GraphQLObjectType && dict.types[ofType.name].inputType) {
     if (!fieldEntry.extensions || !fieldEntry.extensions.relation
       || !fieldEntry.extensions.relation.embedded) {
       const oneToMany = createOneToManyInputType(inputNamePrefix, fieldEntryName,
-        typesDict.types[ofType.name].inputType, typesDictForUpdate.types[ofType.name].inputType);
+        typesDict.types[ofType.name].inputType, typesDictForUpdate.types[ofType.name].inputType, connectionField);
       return oneToMany;
     }
     if (fieldEntry.extensions && fieldEntry.extensions.relation
@@ -211,8 +314,7 @@ const buildInputType = (gqltype) => {
         if (fieldEntry.type instanceof GraphQLScalarType
           || fieldEntry.type instanceof GraphQLEnumType
           || isNonNullOfType(fieldEntry.type, GraphQLScalarType)
-          || isNonNullOfType(fieldEntry.type, GraphQLEnumType)
-        ) {
+          || isNonNullOfType(fieldEntry.type, GraphQLEnumType)) {
           if (fieldEntryName !== 'id') {
             fieldArg.type = fieldEntry.type;
           }
@@ -244,8 +346,8 @@ const buildInputType = (gqltype) => {
           if (fieldEntry.type.ofType === gqltype) {
             selfReferenceCollections[fieldEntryName] = fieldEntry;
           } else {
-            const listInputTypeForAdd = graphQLListInputType(typesDict, fieldEntry, fieldEntryName, 'A');
-            const listInputTypeForUpdate = graphQLListInputType(typesDictForUpdate, fieldEntry, fieldEntryName, 'U');
+            const listInputTypeForAdd = graphQLListInputType(typesDict, fieldEntry, fieldEntryName, 'A', fieldEntry.extensions?.relation?.connectionField);
+            const listInputTypeForUpdate = graphQLListInputType(typesDictForUpdate, fieldEntry, fieldEntryName, 'U', fieldEntry.extensions?.relation?.connectionField);
             if (listInputTypeForAdd && listInputTypeForUpdate) {
               fieldArg.type = listInputTypeForAdd;
               fieldArgForUpdate.type = listInputTypeForUpdate;
@@ -288,7 +390,7 @@ const buildInputType = (gqltype) => {
   Object.keys(selfReferenceCollections).forEach((fieldEntryName) => {
     if (Object.prototype.hasOwnProperty.call(selfReferenceCollections, fieldEntryName)) {
       inputTypeForAddFields[fieldEntryName] = {
-        type: createOneToManyInputType('A', fieldEntryName, inputTypeForAdd, inputTypeForUpdate),
+        type: createOneToManyInputType('A', fieldEntryName, inputTypeForAdd, inputTypeForUpdate, selfReferenceCollections[fieldEntryName].extensions?.relation?.connectionField),
         name: fieldEntryName,
       };
     }
@@ -301,7 +403,7 @@ const buildInputType = (gqltype) => {
   Object.keys(selfReferenceCollections).forEach((fieldEntryName) => {
     if (Object.prototype.hasOwnProperty.call(selfReferenceCollections, fieldEntryName)) {
       inputTypeForUpdateFields[fieldEntryName] = {
-        type: createOneToManyInputType('U', fieldEntryName, inputTypeForAdd, inputTypeForUpdate),
+        type: createOneToManyInputType('U', fieldEntryName, inputTypeForAdd, inputTypeForUpdate, selfReferenceCollections[fieldEntryName].extensions?.relation?.connectionField),
         name: fieldEntryName,
       };
     }
@@ -382,6 +484,8 @@ const materializeModel = async (args, gqltype, linkToParent, operation, session)
               null, operation, session)).modelArgs;
           }
         } else {
+          modelArgs[fieldEntry.name] = new mongoose.Types
+            .ObjectId(args[fieldEntryName].id);
           console.warn(`Configuration issue: Field ${fieldEntryName} does not define extensions.relation`);
         }
       } else if (fieldEntry.type instanceof GraphQLList) {
@@ -462,15 +566,24 @@ const iterateonCollectionFields = async (materializedModel, gqltype, objectId, s
   }
 };
 
-const onDeleteObject = async (Model, gqltype, controller, args, session, linkToParent) => {
-  const result = await materializeModel(args, gqltype, linkToParent, 'DELETE', session);
-  const deletedObject = new Model(result.modelArgs);
+const onDeleteObject = async (Model, gqltype, controller, args, session) => {
+  const deletedObject = await Model.findById({ _id: args }).session(session).lean();
 
   if (controller && controller.onDelete) {
     await controller.onDelete(deletedObject, session);
   }
 
-  return Model.findByIdAndDelete(args, deletedObject.modelArgs).session(session);
+  return Model.findByIdAndDelete({ _id: args }).session(session);
+};
+
+const onDeleteSubject = async (Model, controller, id, session) => {
+  const currentObject = await Model.findById({ _id: id }).session(session).lean();
+
+  if (controller && controller.onDelete) {
+    await controller.onDelete(currentObject, session);
+  }
+
+  return Model.findByIdAndDelete({ _id: id }).session(session);
 };
 
 const onUpdateSubject = async (Model, gqltype, controller, args, session, linkToParent) => {
@@ -481,7 +594,6 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
     await iterateonCollectionFields(materializedModel, gqltype, objectId, session);
   }
 
-  let modifiedObject = materializedModel.modelArgs;
   const currentObject = await Model.findById({ _id: objectId }).lean();
 
   const argTypes = gqltype.getFields();
@@ -490,32 +602,32 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
     if (fieldEntry.extensions && fieldEntry.extensions.relation
       && fieldEntry.extensions.relation.embedded) {
       const oldObjectData = currentObject[fieldEntryName];
-      const newObjectData = modifiedObject[fieldEntryName];
+      const newObjectData = materializedModel.modelArgs[fieldEntryName];
       if (newObjectData) {
         if (Array.isArray(oldObjectData) && Array.isArray(newObjectData)) {
-          modifiedObject[fieldEntryName] = newObjectData;
+          materializedModel.modelArgs[fieldEntryName] = newObjectData;
         } else {
-          modifiedObject[fieldEntryName] = { ...oldObjectData, ...newObjectData };
+          materializedModel.modelArgs[fieldEntryName] = { ...oldObjectData, ...newObjectData };
         }
       }
     }
 
     if (args[fieldEntryName] === null
       && !(fieldEntry.type instanceof GraphQLNonNull)) {
-      modifiedObject = { ...modifiedObject, $unset: { [fieldEntryName]: '' } };
+      materializedModel.modelArgs = { ...materializedModel.modelArgs, $unset: { [fieldEntryName]: '' } };
     }
   });
 
   if (controller && controller.onUpdating) {
-    await controller.onUpdating(objectId, modifiedObject, args, session);
+    await controller.onUpdating(objectId, materializedModel.modelArgs, session);
   }
 
   const result = Model.findByIdAndUpdate(
-    objectId, modifiedObject, { new: true },
-  );
+    objectId, materializedModel.modelArgs, { new: true },
+  ).session(session);
 
   if (controller && controller.onUpdated) {
-    await controller.onUpdated(result, args, session);
+    await controller.onUpdated(result, session);
   }
 
   return result;
@@ -633,7 +745,10 @@ const executeItemFunction = async (gqltype, collectionField, objectId, session,
       };
       break;
     case operations.DELETE:
-    // TODO: implement
+      operationFunction = async (collectionItem) => {
+        await onDeleteSubject(typesDict.types[collectionGQLType.name].model,
+          typesDict.types[collectionGQLType.name].controller, collectionItem, session);
+      };
   }
 
   for (const element of collectionFieldsList) {
@@ -793,10 +908,18 @@ const generateSchemaDefinition = (gqlType) => {
   const schemaArg = {};
 
   for (const [fieldEntryName, fieldEntry] of Object.entries(argTypes)) {
+    // Helper function to get the base scalar type for custom validated scalars
+    const getBaseScalarType = (scalarType) => scalarType.baseScalarType || scalarType;
+
+    // Helper function to check if a type is a custom validated scalar
+    const isCustomValidatedScalar = (type) => type instanceof GraphQLScalarType && type.baseScalarType;
+
     if (fieldEntry.type === GraphQLID || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLID)) {
       schemaArg[fieldEntryName] = mongoose.Schema.Types.ObjectId;
     } else if (fieldEntry.type === GraphQLString
-      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLString)) {
+      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLString)
+      || (isCustomValidatedScalar(fieldEntry.type) && getBaseScalarType(fieldEntry.type) === GraphQLString)
+      || (isNonNullOfType(fieldEntry.type, GraphQLScalarType) && isCustomValidatedScalar(fieldEntry.type.ofType) && getBaseScalarType(fieldEntry.type.ofType) === GraphQLString)) {
       if (fieldEntry.extensions && fieldEntry.extensions.unique) {
         schemaArg[fieldEntryName] = { type: String, unique: true };
       } else {
@@ -810,27 +933,33 @@ const generateSchemaDefinition = (gqlType) => {
         schemaArg[fieldEntryName] = String;
       }
     } else if (fieldEntry.type === GraphQLInt
-      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLInt)) {
+      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLInt)
+      || (isCustomValidatedScalar(fieldEntry.type) && getBaseScalarType(fieldEntry.type) === GraphQLInt)
+      || (isNonNullOfType(fieldEntry.type, GraphQLScalarType) && isCustomValidatedScalar(fieldEntry.type.ofType) && getBaseScalarType(fieldEntry.type.ofType) === GraphQLInt)) {
       if (fieldEntry.extensions && fieldEntry.extensions.unique) {
         schemaArg[fieldEntryName] = { type: Number, unique: true };
       } else {
         schemaArg[fieldEntryName] = Number;
       }
     } else if (fieldEntry.type === GraphQLFloat
-      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLFloat)) {
+      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLFloat)
+      || (isCustomValidatedScalar(fieldEntry.type) && getBaseScalarType(fieldEntry.type) === GraphQLFloat)
+      || (isNonNullOfType(fieldEntry.type, GraphQLScalarType) && isCustomValidatedScalar(fieldEntry.type.ofType) && getBaseScalarType(fieldEntry.type.ofType) === GraphQLFloat)) {
       if (fieldEntry.extensions && fieldEntry.extensions.unique) {
         schemaArg[fieldEntryName] = { type: Number, unique: true };
       } else {
         schemaArg[fieldEntryName] = Number;
       }
     } else if (fieldEntry.type === GraphQLBoolean
-      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLBoolean)) {
+      || isNonNullOfTypeForNotScalar(fieldEntry.type, GraphQLBoolean)
+      || (isCustomValidatedScalar(fieldEntry.type) && getBaseScalarType(fieldEntry.type) === GraphQLBoolean)
+      || (isNonNullOfType(fieldEntry.type, GraphQLScalarType) && isCustomValidatedScalar(fieldEntry.type.ofType) && getBaseScalarType(fieldEntry.type.ofType) === GraphQLBoolean)) {
       schemaArg[fieldEntryName] = Boolean;
     } else if (fieldEntry.type instanceof GraphQLObjectType
       || isNonNullOfType(fieldEntry.type, GraphQLObjectType)) {
       if (fieldEntry.extensions && fieldEntry.extensions.relation) {
         if (!fieldEntry.extensions.relation.embedded) {
-          schemaArg[fieldEntry.extensions.relation.connectionField] = mongoose
+          schemaArg[fieldEntry.extensions.relation.connectionField ? fieldEntry.extensions.relation.connectionField : fieldEntry.name] = mongoose
             .Schema.Types.ObjectId;
         } else {
           let entryType = fieldEntry.type;
@@ -855,17 +984,20 @@ const generateSchemaDefinition = (gqlType) => {
           }
         }
       } else if (fieldEntry.type.ofType === GraphQLString
-        || fieldEntry.type.ofType instanceof GraphQLEnumType) {
+        || fieldEntry.type.ofType instanceof GraphQLEnumType
+        || (isCustomValidatedScalar(fieldEntry.type.ofType) && getBaseScalarType(fieldEntry.type.ofType) === GraphQLString)) {
         schemaArg[fieldEntryName] = [String];
-      } else if (fieldEntry.type.ofType === GraphQLBoolean) {
+      } else if (fieldEntry.type.ofType === GraphQLBoolean
+        || (isCustomValidatedScalar(fieldEntry.type.ofType) && getBaseScalarType(fieldEntry.type.ofType) === GraphQLBoolean)) {
         schemaArg[fieldEntryName] = [Boolean];
-      } else if (fieldEntry.type.ofType === GraphQLInt || fieldEntry.type.ofType === GraphQLFloat) {
+      } else if (fieldEntry.type.ofType === GraphQLInt || fieldEntry.type.ofType === GraphQLFloat
+        || (isCustomValidatedScalar(fieldEntry.type.ofType) && (getBaseScalarType(fieldEntry.type.ofType) === GraphQLInt || getBaseScalarType(fieldEntry.type.ofType) === GraphQLFloat))) {
         schemaArg[fieldEntryName] = [Number];
-      } else if (isGraphQLisoDate(fieldEntry.type.ofType.name)) {
+      } else if (isGraphQLisoDate(getEffectiveTypeName(fieldEntry.type.ofType))) {
         schemaArg[fieldEntryName] = [Date];
       }
-    } else if (isGraphQLisoDate(fieldEntry.type.name)
-    || (fieldEntry.type instanceof GraphQLNonNull && isGraphQLisoDate(fieldEntry.type.ofType.name))) {
+    } else if (isGraphQLisoDate(getEffectiveTypeName(fieldEntry.type))
+    || (fieldEntry.type instanceof GraphQLNonNull && isGraphQLisoDate(getEffectiveTypeName(fieldEntry.type.ofType)))) {
       schemaArg[fieldEntryName] = Date;
     }
   }
@@ -878,7 +1010,18 @@ const generateModel = (gqlType, onModelCreated) => {
   if (onModelCreated) {
     onModelCreated(model);
   }
-  model.createCollection();
+  if (!preventCollectionCreation) {
+    model.createCollection();
+  }
+  return model;
+};
+
+const generateModelWithoutCollection = (gqlType, onModelCreated) => {
+  const model = mongoose.model(gqlType.name, generateSchemaDefinition(gqlType), gqlType.name);
+  if (onModelCreated) {
+    onModelCreated(model);
+  }
+  // Never create collection for no-endpoint types
   return model;
 };
 
@@ -939,13 +1082,12 @@ const buildAggregationsForSort = (filterField, qlField, fieldName) => {
     if (fieldType instanceof GraphQLNonNull) {
       fieldType = qlField.type.ofType;
     }
-
     filterField.terms.forEach((term) => {
       if (qlField.extensions && qlField.extensions.relation
         && !qlField.extensions.relation.embedded) {
         const { model } = typesDict.types[fieldType.name];
         const { collectionName } = model.collection;
-        const localFieldName = qlField.extensions.relation.connectionField;
+        const localFieldName = qlField.extensions?.relation?.connectionField || fieldName;
         if (!aggregateClauses[fieldName]) {
           let lookup = {};
 
@@ -1003,7 +1145,7 @@ const buildAggregationsForSort = (filterField, qlField, fieldName) => {
 
             const pathModel = typesDict.types[pathFieldType.name].model;
             const fieldPathCollectionName = pathModel.collection.collectionName;
-            const pathLocalFieldName = pathField.extensions.relation.connectionField;
+            const pathLocalFieldName = pathField.extensions?.relation?.connectionField || pathFieldName;
 
             if (!aggregateClauses[aliasPath]) {
               let lookup = {};
@@ -1056,7 +1198,7 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
     || isNonNullOfType(fieldType, GraphQLScalarType)
     || fieldType instanceof GraphQLEnumType
     || isNonNullOfType(fieldType, GraphQLEnumType)) {
-    const fieldTypeName = fieldType instanceof GraphQLNonNull ? fieldType.ofType.name : fieldType.name;
+    const fieldTypeName = fieldType instanceof GraphQLNonNull ? getEffectiveTypeName(fieldType.ofType) : getEffectiveTypeName(fieldType);
     if (isGraphQLisoDate(fieldTypeName)) {
       if (Array.isArray(filterField.value)) {
         filterField.value = filterField.value.map((value) => value && new Date(value));
@@ -1076,7 +1218,7 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
         && !qlField.extensions.relation.embedded) {
         const { model } = typesDict.types[fieldType.name];
         const { collectionName } = model.collection;
-        const localFieldName = qlField.extensions.relation.connectionField;
+        const localFieldName = qlField.extensions?.relation?.connectionField || fieldName;
         if (!aggregateClauses[fieldName]) {
           let lookup = {};
 
@@ -1109,7 +1251,7 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
 
       if (term.path.indexOf('.') < 0) {
         const { type } = fieldType.getFields()[term.path];
-        const typeName = type instanceof GraphQLNonNull ? type.ofType.name : type.name;
+        const typeName = type instanceof GraphQLNonNull ? getEffectiveTypeName(type.ofType) : getEffectiveTypeName(type);
         if (isGraphQLisoDate(typeName)) {
           if (Array.isArray(term.value)) {
             term.value = term.value.map((value) => value && new Date(value));
@@ -1131,7 +1273,7 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
           const pathField = currentGQLPathFieldType.getFields()[pathFieldName];
           if (pathField.type instanceof GraphQLScalarType
             || isNonNullOfType(pathField.type, GraphQLScalarType)) {
-            const typeName = pathField.type instanceof GraphQLNonNull ? pathField.type.ofType.name : pathField.type.name;
+            const typeName = pathField.type instanceof GraphQLNonNull ? getEffectiveTypeName(pathField.type.ofType) : getEffectiveTypeName(pathField.type);
             if (isGraphQLisoDate(typeName)) {
               if (Array.isArray(term.value)) {
                 term.value = term.value.map((value) => value && new Date(value));
@@ -1158,7 +1300,7 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
 
               const pathModel = typesDict.types[pathFieldType.name].model;
               const fieldPathCollectionName = pathModel.collection.collectionName;
-              const pathLocalFieldName = pathField.extensions.relation.connectionField;
+              const pathLocalFieldName = pathField.extensions?.relation?.connectionField || pathFieldName;
 
               if (!aggregateClauses[aliasPath]) {
                 let lookup = {};
@@ -1411,6 +1553,52 @@ module.exports.registerMutation = (name, description, inputModel, outputModel, c
   };
 };
 
+const autoGenerateResolvers = (gqltype) => {
+  const fields = gqltype.getFields();
+
+  for (const [fieldName, fieldEntry] of Object.entries(fields)) {
+    // Skip if resolve method already exists
+    if (!fieldEntry.resolve) {
+      // Check if field has relation extension
+      if (fieldEntry.extensions && fieldEntry.extensions.relation) {
+        const { relation } = fieldEntry.extensions;
+
+        if (fieldEntry.type instanceof GraphQLList) {
+          // Collection field - generate resolve for one-to-many relationship
+          const relatedType = fieldEntry.type.ofType;
+          const connectionField = relation.connectionField || fieldName;
+
+          fieldEntry.resolve = (parent) => {
+            // 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);
+          };
+        } else if (fieldEntry.type instanceof GraphQLObjectType
+                   || (fieldEntry.type instanceof GraphQLNonNull && fieldEntry.type.ofType instanceof GraphQLObjectType)) {
+          // Single object field - generate resolve for one-to-one relationship
+          const relatedType = fieldEntry.type instanceof GraphQLNonNull ? fieldEntry.type.ofType : fieldEntry.type;
+          const connectionField = relation.connectionField || fieldName;
+
+          fieldEntry.resolve = (parent) => {
+            // 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 relatedId = parent[connectionField] || parent[fieldName];
+            return relatedId ? relatedTypeInfo.model.findById(relatedId) : null;
+          };
+        }
+      }
+    }
+  }
+};
+
 module.exports.connect = (model, gqltype, simpleEntityEndpointName,
   listEntitiesEndpointName, controller, onModelCreated, stateMachine) => {
   waitingInputType[gqltype.name] = {
@@ -1428,6 +1616,9 @@ module.exports.connect = (model, gqltype, simpleEntityEndpointName,
   };
 
   typesDictForUpdate.types[gqltype.name] = { ...typesDict.types[gqltype.name] };
+
+  // Auto-generate resolve methods for relationship fields if not already defined
+  autoGenerateResolvers(gqltype);
 };
 
 module.exports.addNoEndpointType = (gqltype) => {
@@ -1435,10 +1626,30 @@ module.exports.addNoEndpointType = (gqltype) => {
     gqltype,
   };
 
+  // Check if this type has relationship fields that might need a model
+  const fields = gqltype.getFields();
+  let needsModel = false;
+
+  for (const [, fieldEntry] of Object.entries(fields)) {
+    if (fieldEntry.extensions && fieldEntry.extensions.relation
+        && (fieldEntry.type instanceof GraphQLObjectType || fieldEntry.type instanceof GraphQLList
+            || (fieldEntry.type instanceof GraphQLNonNull && fieldEntry.type.ofType instanceof GraphQLObjectType))) {
+      needsModel = true;
+      break;
+    }
+  }
+
   typesDict.types[gqltype.name] = {
     gqltype,
     endpoint: false,
+    // Generate model if needed for relationships, but don't create collection
+    model: needsModel ? generateModelWithoutCollection(gqltype, null) : null,
   };
 
   typesDictForUpdate.types[gqltype.name] = { ...typesDict.types[gqltype.name] };
+
+  // Auto-generate resolve methods for relationship fields if not already defined
+  autoGenerateResolvers(gqltype);
 };
+
+module.exports.createValidatedScalar = createValidatedScalar;

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

@@ -0,0 +1,63 @@
+const mongoose = require('mongoose');
+const { GraphQLObjectType, GraphQLString, GraphQLID } = require('graphql');
+const simfinity = require('../src/index');
+
+describe('preventCreatingCollection option', () => {
+  let createCollectionSpy;
+
+  beforeEach(() => {
+    // Reset modules to have a clean state for each test
+    jest.resetModules();
+    // Spy on the createCollection method of the mongoose model prototype
+    createCollectionSpy = jest.spyOn(mongoose.Model, 'createCollection').mockImplementation(() => Promise.resolve());
+  });
+
+  afterEach(() => {
+    // Restore the original implementation
+    createCollectionSpy.mockRestore();
+  });
+
+  test('should create collection by default', () => {
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeDefault',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+      }),
+    });
+
+    simfinity.connect(null, TestType, 'testTypeDefault', 'testTypesDefault');
+    expect(createCollectionSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('should NOT create collection when preventCreatingCollection is true', () => {
+    simfinity.preventCreatingCollection(true);
+
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypePrevent',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+      }),
+    });
+
+    simfinity.connect(null, TestType, 'testTypePrevent', 'testTypesPrevent');
+    expect(createCollectionSpy).not.toHaveBeenCalled();
+  });
+
+  test('should create collection when preventCreatingCollection is set back to false', () => {
+    simfinity.preventCreatingCollection(true); // first prevent
+    simfinity.preventCreatingCollection(false); // then allow
+
+    const TestType = new GraphQLObjectType({
+      name: 'TestTypeAllow',
+      fields: () => ({
+        id: { type: GraphQLID },
+        name: { type: GraphQLString },
+      }),
+    });
+
+    simfinity.connect(null, TestType, 'testTypeAllow', 'testTypesAllow');
+    expect(createCollectionSpy).toHaveBeenCalledTimes(1);
+  });
+});