@simtlix/simfinity-js 1.2.0 → 1.3.0

package/eslint.config.mjs

@@ -0,0 +1,63 @@
+import globals from "globals";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default [
+    {
+        ignores: ["node_modules/*", "data/*", "eslint.config.mjs"],
+    },
+    ...compat.extends("airbnb-base"),
+    {
+        files: ["**/*.js"],
+        languageOptions: {
+            globals: {
+                ...globals.commonjs,
+                ...globals.node,
+                ...globals.jest,
+            },
+
+            ecmaVersion: 2024,
+            sourceType: "commonjs",
+        },
+
+        rules: {
+            "default-case": "off",
+            "max-len": 0,
+            "no-console": "off",
+            "no-underscore-dangle": "off",
+            "no-await-in-loop": "off",
+
+            "no-param-reassign": ["error", {
+                props: false,
+            }],
+
+            "function-paren-newline": "off",
+            "function-call-argument-newline": "off",
+
+            "no-restricted-syntax": ["error", {
+                selector: "ForInStatement",
+                message: "for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array.",
+            }, {
+                selector: "LabeledStatement",
+                message: "Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand.",
+            }, {
+                selector: "WithStatement",
+                message: "`with` is disallowed in strict mode because it makes code impossible to predict and optimize.",
+            }],
+
+            "import/no-unresolved": ["error", {
+                ignore: ["graphql", "mongoose"],
+            }],
+        },
+    },
+];

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "@simtlix/simfinity-js",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "main": "src/index.js",
   "scripts": {
-    "test": "echo \"No test specified\"",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "lint": "eslint '**/*.js'",
     "lint-fix": "eslint --fix '**/*.js'"
   },
+  "engines": {
+    "node": ">=18.18.0"
+  },
   "author": "Simtlix",
   "license": "Apache-2.0",
   "repository": {
@@ -19,10 +24,15 @@
     "mongoose": "^8.15.1"
   },
   "devDependencies": {
-    "eslint": "^7.7.0",
-    "eslint-config-airbnb-base": "^14.2.0",
-    "eslint-plugin-import": "^2.22.0",
-    "ghooks": "^2.0.4"
+    "@eslint/compat": "^1.2.0",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.30.1",
+    "eslint": "^9.30.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.32.0",
+    "ghooks": "^2.0.4",
+    "globals": "^16.3.0",
+    "jest": "^29.0.0"
   },
   "config": {
     "ghooks": {
@@ -33,5 +43,15 @@
   "optionalDependencies": {
     "graphql": "^14.7.0",
     "mongoose": "^8.15.1"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.js",
+      "!src/index.js"
+    ]
   }
 }

package/src/index.js

@@ -12,7 +12,7 @@ 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);
+  }
+
+  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) => {
+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,25 +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({ _id: args.id }).session(session);
+  return Model.findByIdAndDelete({ _id: args }).session(session);
 };
 
 const onDeleteSubject = async (Model, controller, id, session) => {
-  const currentObject = await Model.findById({ _id: id }).lean();
+  const currentObject = await Model.findById({ _id: id }).session(session).lean();
 
   if (controller && controller.onDelete) {
     await controller.onDelete(currentObject, session);
   }
 
-  return Model.findByIdAndDelete(id, { session });
+  return Model.findByIdAndDelete({ _id: id }).session(session);
 };
 
 const onUpdateSubject = async (Model, gqltype, controller, args, session, linkToParent) => {
@@ -805,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 {
@@ -822,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;
@@ -867,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;
     }
   }
@@ -890,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;
 };
 
@@ -951,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 = {};
 
@@ -1015,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 = {};
@@ -1068,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));
@@ -1088,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 = {};
 
@@ -1121,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));
@@ -1143,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));
@@ -1170,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 = {};
@@ -1423,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] = {
@@ -1440,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) => {
@@ -1447,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;