Merge branch 'master' of https://github.com/graphql-compose/graphql-compose-mongoose

Author: jhbuchanan45

package.json

@@ -34,23 +34,23 @@
   },
   "devDependencies": {
     "@types/jest": "26.0.24",
-    "@typescript-eslint/eslint-plugin": "4.28.2",
-    "@typescript-eslint/parser": "4.28.2",
-    "eslint": "7.30.0",
+    "@typescript-eslint/eslint-plugin": "4.28.4",
+    "@typescript-eslint/parser": "4.28.4",
+    "eslint": "7.31.0",
     "eslint-config-airbnb-base": "14.2.1",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-import": "2.23.4",
     "eslint-plugin-prettier": "3.4.0",
     "graphql": "15.5.1",
     "graphql-compose": "9.0.1",
     "jest": "27.0.6",
-    "mongodb-memory-server": "7.2.0",
-    "mongoose": "5.13.2",
+    "mongodb-memory-server": "7.3.2",
+    "mongoose": "5.13.3",
     "prettier": "2.3.2",
     "request": "2.88.2",
     "rimraf": "3.0.2",
     "semantic-release": "17.4.4",
-    "ts-jest": "27.0.3",
+    "ts-jest": "27.0.4",
     "typescript": "4.3.5"
   },
   "scripts": {

src/__tests__/github_issues/358-test.ts

@@ -0,0 +1,42 @@
+import { composeMongoose } from '../../index';
+import { mongoose } from '../../__mocks__/mongooseCommon';
+
+// mongoose.set('debug', true);
+
+const WithSubSchema = new mongoose.Schema({
+  subDocument: new mongoose.Schema({
+    field: { type: String, default: 'Hey' },
+  }),
+});
+
+const WithoutSubSchema = new mongoose.Schema({
+  subDocument: {
+    field: { type: String, default: 'Hey' },
+  },
+});
+
+const WithSubModel = mongoose.model('WithSubModel', WithSubSchema);
+const WithoutSubModel = mongoose.model('WithoutSubModel', WithoutSubSchema);
+
+describe('defaultsAsNonNull falsely reports non-nullability for subdocuments that have a Schema  - issue #358', () => {
+  it('with sub schema', async () => {
+    const WithSubTC = composeMongoose(WithSubModel, { defaultsAsNonNull: true });
+
+    // sub-Schema breaks the "recursive default value assignation" behavior
+    const data = new WithSubModel().subDocument;
+    expect(data).toEqual(undefined);
+
+    // so field should not be non-null
+    expect(WithSubTC.getFieldTypeName('subDocument')).toBe('WithSubModelSubDocument');
+  });
+
+  it('as nested fields', async () => {
+    const WithoutSubTC = composeMongoose(WithoutSubModel, { defaultsAsNonNull: true });
+
+    const data = new WithoutSubModel().subDocument;
+    expect(data).toEqual({ field: 'Hey' });
+
+    // should be non-null!
+    expect(WithoutSubTC.getFieldTypeName('subDocument')).toBe('WithoutSubModelSubDocument!');
+  });
+});

src/composeMongoose.ts

@@ -173,6 +173,12 @@ function makeFieldsNonNullWithDefaultValues(
     const fc = tc.getField(fieldName);
     // traverse nested Object types
     if (fc.type instanceof ObjectTypeComposer) {
+      if (fc.extensions?.isSingleNestedMongooseSchema) {
+        // sub-Schema breaks the "recursive default value assignation" behavior
+        // @see https://github.com/graphql-compose/graphql-compose-mongoose/issues/358
+        return;
+      }
+
       makeFieldsNonNullWithDefaultValues(fc.type);
       if (fc.type.getExtension('hasFieldsWithDefaultValue')) {
         tc.makeFieldNonNull(fieldName);

src/fieldsConverter.ts

@@ -205,6 +205,12 @@ export function convertModelToGraphQL<TDoc extends Document, TContext>(
       description: _getFieldDescription(mongooseField),
     };
 
+    if (mongooseField?.schema && (mongooseField as any)?.$isSingleNested) {
+      graphqlFields[fieldName].extensions = {
+        isSingleNestedMongooseSchema: true,
+      };
+    }
+
     if (mongooseField?.defaultValue !== null && mongooseField?.defaultValue !== undefined) {
       if (!graphqlFields[fieldName].extensions) graphqlFields[fieldName].extensions = {};
       (graphqlFields as any)[fieldName].extensions.defaultValue = mongooseField?.defaultValue;

src/resolvers/connection.ts

@@ -24,6 +24,8 @@ export type ConnectionResolverOpts<TContext = any> = Omit<
   _ConnectionResolverOpts<TContext>,
   'countResolver' | 'findManyResolver' | 'sort'
 > & {
+  findManyResolver?: Resolver;
+  countResolver?: Resolver;
   countOpts?: CountResolverOpts;
   findManyOpts?: FindManyResolverOpts;
   sort?: _ConnectionSortMapOpts;
@@ -61,11 +63,11 @@ export function connection<TSource = any, TContext = any, TDoc extends Document
     };
   });
 
-  const { findManyOpts, countOpts, ...restOpts } = opts || {};
+  const { findManyOpts, countOpts, findManyResolver, countResolver, ...restOpts } = opts || {};
 
   return prepareConnectionResolver<any, any>(tc, {
-    findManyResolver: findMany(model, tc, findManyOpts),
-    countResolver: count(model, tc, countOpts),
+    findManyResolver: findManyResolver || findMany(model, tc, findManyOpts),
+    countResolver: countResolver || count(model, tc, countOpts),
     sort: sortConfigs,
     ...restOpts,
   });

src/resolvers/helpers/filter.ts

@@ -4,6 +4,7 @@ import {
   ObjectTypeComposer,
   InterfaceTypeComposer,
   ObjectTypeComposerArgumentConfigMap,
+  InputTypeComposer,
 } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
 import { isObject, toMongoFilterDottedObject, getIndexedFieldNamesForGraphQL } from '../../utils';
@@ -102,24 +103,30 @@ export function filterHelperArgs<TDoc extends Document = any>(
 
   const { prefix, suffix } = opts;
   const filterTypeName: string = `${prefix}${typeComposer.getTypeName()}${suffix}`;
-  const itc = typeComposer.getInputTypeComposer().clone(filterTypeName);
 
-  makeFieldsRecursiveNullable(itc, { prefix, suffix });
+  let itc;
+  if (typeComposer.schemaComposer.hasInstance(filterTypeName, InputTypeComposer)) {
+    itc = typeComposer.schemaComposer.getITC(filterTypeName);
+  } else {
+    itc = typeComposer.getInputTypeComposer().clone(filterTypeName);
 
-  itc.removeField(removeFields);
+    makeFieldsRecursiveNullable(itc, { prefix, suffix });
 
-  if (opts.requiredFields) {
-    itc.makeFieldNonNull(opts.requiredFields);
-  }
+    itc.removeField(removeFields);
 
-  if (itc.getFieldNames().length === 0) {
-    return {} as any;
-  }
+    if (opts.requiredFields) {
+      itc.makeFieldNonNull(opts.requiredFields);
+    }
 
-  if (!opts.baseTypeName) {
-    opts.baseTypeName = typeComposer.getTypeName();
+    if (itc.getFieldNames().length === 0) {
+      return {} as any;
+    }
+
+    if (!opts.baseTypeName) {
+      opts.baseTypeName = typeComposer.getTypeName();
+    }
+    addFilterOperators(itc, model, opts);
   }
-  addFilterOperators(itc, model, opts);
 
   return {
     filter: {

src/resolvers/pagination.ts

@@ -13,6 +13,8 @@ export type PaginationResolverOpts = Omit<
   _PaginationResolverOpts,
   'countResolver' | 'findManyResolver'
 > & {
+  findManyResolver?: Resolver;
+  countResolver?: Resolver;
   countOpts?: CountResolverOpts;
   findManyOpts?: FindManyResolverOpts;
 };
@@ -22,10 +24,10 @@ export function pagination<TSource = any, TContext = any, TDoc extends Document
   tc: ObjectTypeComposer<TDoc, TContext> | InterfaceTypeComposer<TDoc, TContext>,
   opts?: PaginationResolverOpts
 ): Resolver<TSource, TContext, PaginationTArgs, TDoc> {
-  const { countOpts, findManyOpts, ...restOpts } = opts || {};
+  const { countOpts, findManyOpts, findManyResolver, countResolver, ...restOpts } = opts || {};
   const resolver = preparePaginationResolver<any, any>(tc, {
-    findManyResolver: findMany(model, tc, findManyOpts),
-    countResolver: count(model, tc, countOpts),
+    findManyResolver: findManyResolver || findMany(model, tc, findManyOpts),
+    countResolver: countResolver || count(model, tc, countOpts),
     ...restOpts,
   });
   return resolver;