test: improve 271 test suite and add tsts for 253 issus – for proper testing aliases with projections & descriminators

Author: nodkz

src/__tests__/github_issues/253-test.ts

@@ -0,0 +1,61 @@
+import { schemaComposer } from 'graphql-compose';
+import { composeWithMongooseDiscriminators } from '../../index';
+import { mongoose, Schema } from '../../__mocks__/mongooseCommon';
+import { testFieldConfig } from '../../utils/testHelpers';
+
+const SubCarSchema = new Schema({ s: { type: Number, required: true, alias: 'speed' } });
+
+const CarSchema = new Schema(
+  { s: { type: Number, required: true, alias: 'speed' }, aaa: SubCarSchema },
+  { discriminatorKey: 't' }
+);
+const Car = mongoose.model('Car', CarSchema);
+
+const TimeMachineSchema = new Schema(
+  { f: { type: Number, required: true, alias: 'fluxCompensatorVersion' } },
+  { discriminatorKey: 't' }
+);
+const TimeMachine = Car.discriminator('TimeMachine', TimeMachineSchema);
+
+const CarDTC = composeWithMongooseDiscriminators(Car);
+
+schemaComposer.Query.addFields({
+  allCars: CarDTC.getResolver('findMany'),
+  timeMachines: CarDTC.discriminator(TimeMachine).getResolver('findMany'),
+});
+
+// console.log(schemaComposer.toSDL({ omitDescriptions: true }));
+
+beforeAll(async () => {
+  await mongoose.createConnection();
+  await TimeMachine.create({ speed: 300, fluxCompensatorVersion: 5 });
+});
+afterAll(() => mongoose.disconnect());
+
+describe('issue #253 - Consider aliases from discriminators during preparation', () => {
+  it('check data in db', async () => {
+    const data = await Car.find({}).lean();
+    expect(data).toEqual([{ __v: 0, _id: expect.anything(), f: 5, s: 300, t: 'TimeMachine' }]);
+  });
+
+  it('check query', async () => {
+    const res = await testFieldConfig({
+      field: CarDTC.getResolver('findMany'),
+      selection: `{
+        __typename
+        speed
+        ... on TimeMachine {
+          fluxCompensatorVersion
+        }
+      }`,
+      schemaComposer,
+    });
+    expect(res).toEqual([
+      {
+        __typename: 'TimeMachine',
+        fluxCompensatorVersion: 5,
+        speed: 300,
+      },
+    ]);
+  });
+});

src/__tests__/github_issues/271-test.ts

@@ -5,10 +5,12 @@ import { Document } from 'mongoose';
 import { convertSchemaToGraphQL } from '../../../src/fieldsConverter';
 const schemaComposer = new SchemaComposer<{ req: any }>();
 
+// mongoose.set('debug', true);
+
 const AuthorSchema = new mongoose.Schema(
   {
     name: { type: String },
-    age: { type: Number },
+    ag: { type: Number, alias: 'age' },
     isAlive: { type: Boolean },
   },
   { _id: false }
@@ -17,8 +19,8 @@ const AuthorSchema = new mongoose.Schema(
 const BookSchema = new mongoose.Schema({
   _id: { type: Number },
   title: { type: String, required: true },
-  pageCount: { type: Number },
-  author: { type: AuthorSchema },
+  pc: { type: Number, alias: 'pageCount' },
+  a: { type: AuthorSchema, alias: 'author' },
 });
 
 interface IAuthor {
@@ -36,25 +38,45 @@ interface IBook extends Document {
 
 const BookModel = mongoose.model<IBook>('Book', BookSchema);
 
-convertSchemaToGraphQL(AuthorSchema, 'Author', schemaComposer);
+const AuthorTC = convertSchemaToGraphQL(AuthorSchema, 'Author', schemaComposer);
+AuthorTC.setField('isAbove100', {
+  type: 'String',
+  resolve: (s: IAuthor) => {
+    return !s?.age ? 'unknown' : s.age > 100 ? 'yes' : 'no';
+  },
+  projection: { age: true },
+});
 
 const BookTC = composeMongoose(BookModel, { schemaComposer });
+BookTC.setField('bookSize', {
+  type: 'String',
+  resolve: (s: IBook) => {
+    return !s?.pageCount ? 'unknown' : s.pageCount > 500 ? 'big' : 'small';
+  },
+  projection: { pageCount: true },
+});
 
+let lastExecutedProjection: Record<string, true>;
 schemaComposer.Query.addFields({
-  bookById: BookTC.mongooseResolvers.findById(),
-  bookFindOne: BookTC.mongooseResolvers.findOne(),
-  booksMany: BookTC.mongooseResolvers.findMany(),
+  booksMany: BookTC.mongooseResolvers.findMany().wrapResolve((next) => async (rp) => {
+    const res = await next(rp);
+    lastExecutedProjection = rp.query._fields;
+    return res;
+  }),
 });
 
 const schema = schemaComposer.buildSchema();
 
 beforeAll(async () => {
-  mongoose.set('debug', true);
   await BookModel.base.createConnection();
   await BookModel.create({
     _id: 1,
     title: 'Atlas Shrugged',
-    author: { age: new Date().getFullYear() - 1905, isAlive: false, name: 'Ayn Rand' },
+    author: {
+      age: 115,
+      isAlive: false,
+      name: 'Ayn Rand',
+    },
     pageCount: 1168,
   });
 });
@@ -63,7 +85,28 @@ afterAll(() => {
   BookModel.base.disconnect();
 });
 
-describe('nested projection - issue #271', () => {
+describe('nested projections with aliases - issue #271', () => {
+  it('check mongoose itself', async () => {
+    const book = (
+      await BookModel.find({}).select({
+        bookSize: true,
+        'a.isAbove100': true,
+        'a.ag': true,
+        pc: true,
+      })
+    )[0];
+    expect(book?.pageCount).toEqual(1168);
+    expect(book?.author?.age).toEqual(115);
+    expect(book?.toObject({ virtuals: true })).toEqual({
+      _id: 1,
+      a: { ag: 115, age: 115, id: null },
+      author: { ag: 115, age: 115, id: null },
+      id: '1',
+      pageCount: 1168,
+      pc: 1168,
+    });
+  });
+
   it('Happy Path', async () => {
     const result = await graphql.graphql({
       schema,
@@ -76,7 +119,12 @@ describe('nested projection - issue #271', () => {
         }`,
       contextValue: {},
     });
-    console.log(JSON.stringify(result));
+    expect(lastExecutedProjection).toEqual({ 'a.name': true, pc: true, title: true });
+    expect(result).toEqual({
+      data: {
+        booksMany: [{ author: { name: 'Ayn Rand' }, pageCount: 1168, title: 'Atlas Shrugged' }],
+      },
+    });
   });
 
   it('Handles a Fragment', async () => {
@@ -90,12 +138,41 @@ describe('nested projection - issue #271', () => {
         query {
           booksMany {
             title
-            pageCount
             author { ...Auth }
           }
         }`,
       contextValue: {},
     });
-    console.log(JSON.stringify(result));
+    expect(lastExecutedProjection).toEqual({ 'a.name': true, title: true });
+    expect(result).toEqual({
+      data: {
+        booksMany: [{ author: { name: 'Ayn Rand' }, title: 'Atlas Shrugged' }],
+      },
+    });
+  });
+
+  it('Handles computable fields which uses `projection` property', async () => {
+    const result = await graphql.graphql({
+      schema,
+      source: `
+        query {
+          booksMany {
+            bookSize
+            author { 
+              isAbove100
+            }
+          }
+        }`,
+      contextValue: {},
+    });
+    expect(lastExecutedProjection).toEqual({
+      bookSize: true,
+      'a.isAbove100': true,
+      'a.ag': true,
+      pc: true,
+    });
+    expect(result).toEqual({
+      data: { booksMany: [{ author: { isAbove100: 'yes' }, bookSize: 'big' }] },
+    });
   });
 });