Fix TS issues in tests

Author: djhi

src/introspection/getFieldsFromEntities.spec.ts

@@ -1,4 +1,5 @@
 import { GraphQLString, GraphQLID, GraphQLNonNull } from 'graphql';
+import { expect, test } from 'vitest';
 import getFieldsFromEntities from './getFieldsFromEntities';
 
 test('does infer field types', () => {

src/introspection/getFilterTypesFromData.spec.ts

@@ -1,3 +1,4 @@
+import { expect, test } from 'vitest';
 import getFilterTypesFromData from './getFilterTypesFromData';
 
 const data = {

src/introspection/getSchemaFromData.spec.ts

@@ -1,13 +1,15 @@
 import {
     GraphQLID,
+    GraphQLInputObjectType,
     GraphQLInt,
     GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
     GraphQLString,
 } from 'graphql';
-import getSchemaFromData from './getSchemaFromData';
 import type { ObjMap } from 'graphql/jsutils/ObjMap';
+import { expect, test } from 'vitest';
+import getSchemaFromData from './getSchemaFromData';
 
 const data = {
     posts: [
@@ -105,36 +107,38 @@ const QueryType = new GraphQLObjectType({
 
 test('creates one type per data type', () => {
     const typeMap = getSchemaFromData(
-        data,
+        data
     ).getTypeMap() as ObjMap<GraphQLObjectType>;
     expect(typeMap.Post.name).toEqual(PostType.name);
     expect(Object.keys(typeMap.Post.getFields())).toEqual(
-        Object.keys(PostType.getFields()),
+        Object.keys(PostType.getFields())
     );
     expect(typeMap.User.name).toEqual(UserType.name);
     expect(Object.keys(typeMap.User.getFields())).toEqual(
-        Object.keys(UserType.getFields()),
+        Object.keys(UserType.getFields())
     );
 });
 
 test('creates one field per relationship', () => {
     const typeMap = getSchemaFromData(
-        data,
+        data
     ).getTypeMap() as ObjMap<GraphQLObjectType>;
     expect(Object.keys(typeMap.Post.getFields())).toContain('User');
 });
 
 test('creates one field per reverse relationship', () => {
     const typeMap = getSchemaFromData(
-        data,
+        data
     ).getTypeMap() as ObjMap<GraphQLObjectType>;
     expect(Object.keys(typeMap.User.getFields())).toContain('Posts');
 });
 
 test('creates three query fields per data type', () => {
     // biome-ignore lint/style/noNonNullAssertion: It's only a test
     const queries = getSchemaFromData(data).getQueryType()!.getFields();
-    expect(queries.Post.type.name).toEqual(PostType.name);
+    expect((queries.Post.type as GraphQLObjectType).name).toEqual(
+        PostType.name
+    );
     expect(queries.Post.args).toEqual([
         expect.objectContaining({
             name: 'id',
@@ -154,7 +158,9 @@ test('creates three query fields per data type', () => {
     expect(queries.allPosts.args[4].type.toString()).toEqual('PostFilter');
     expect(queries._allPostsMeta.type.toString()).toEqual('ListMetadata');
 
-    expect(queries.User.type.name).toEqual(UserType.name);
+    expect((queries.User.type as GraphQLObjectType).name).toEqual(
+        UserType.name
+    );
     expect(queries.User.args).toEqual([
         expect.objectContaining({
             name: 'id',
@@ -178,7 +184,9 @@ test('creates three query fields per data type', () => {
 test('creates three mutation fields per data type', () => {
     // biome-ignore lint/style/noNonNullAssertion: It's only a test
     const mutations = getSchemaFromData(data).getMutationType()!.getFields();
-    expect(mutations.createPost.type.name).toEqual(PostType.name);
+    expect((mutations.createPost.type as GraphQLObjectType).name).toEqual(
+        PostType.name
+    );
     expect(mutations.createPost.args).toEqual([
         expect.objectContaining({
             name: 'title',
@@ -193,7 +201,9 @@ test('creates three mutation fields per data type', () => {
             type: new GraphQLNonNull(GraphQLID),
         }),
     ]);
-    expect(mutations.updatePost.type.name).toEqual(PostType.name);
+    expect((mutations.updatePost.type as GraphQLObjectType).name).toEqual(
+        PostType.name
+    );
     expect(mutations.updatePost.args).toEqual([
         expect.objectContaining({
             name: 'id',
@@ -212,21 +222,27 @@ test('creates three mutation fields per data type', () => {
             type: GraphQLID,
         }),
     ]);
-    expect(mutations.removePost.type.name).toEqual(PostType.name);
+    expect((mutations.removePost.type as GraphQLObjectType).name).toEqual(
+        PostType.name
+    );
     expect(mutations.removePost.args).toEqual([
         expect.objectContaining({
             name: 'id',
             type: new GraphQLNonNull(GraphQLID),
         }),
     ]);
-    expect(mutations.createUser.type.name).toEqual(UserType.name);
+    expect((mutations.createUser.type as GraphQLObjectType).name).toEqual(
+        UserType.name
+    );
     expect(mutations.createUser.args).toEqual([
         expect.objectContaining({
             name: 'name',
             type: new GraphQLNonNull(GraphQLString),
         }),
     ]);
-    expect(mutations.updateUser.type.name).toEqual(UserType.name);
+    expect((mutations.updateUser.type as GraphQLObjectType).name).toEqual(
+        UserType.name
+    );
     expect(mutations.updateUser.args).toEqual([
         expect.objectContaining({
             name: 'id',
@@ -237,7 +253,9 @@ test('creates three mutation fields per data type', () => {
             type: GraphQLString,
         }),
     ]);
-    expect(mutations.removeUser.type.name).toEqual(UserType.name);
+    expect((mutations.removeUser.type as GraphQLObjectType).name).toEqual(
+        UserType.name
+    );
     expect(mutations.removeUser.args).toEqual([
         expect.objectContaining({
             name: 'id',
@@ -251,20 +269,22 @@ test('creates the mutation *Input type for createMany', () => {
     const mutations = getSchemaFromData(data).getMutationType()!.getFields();
     const createManyPostInputType = mutations.createManyPost.args[0].type;
     expect(createManyPostInputType.toString()).toEqual('[PostInput]');
-    expect(createManyPostInputType.ofType.getFields()).toEqual({
-        title: expect.objectContaining({
-            type: new GraphQLNonNull(GraphQLString),
-            name: 'title',
-        }),
-        views: expect.objectContaining({
-            type: new GraphQLNonNull(GraphQLInt),
-            name: 'views',
-        }),
-        user_id: expect.objectContaining({
-            type: new GraphQLNonNull(GraphQLID),
-            name: 'user_id',
-        }),
-    });
+    expect((createManyPostInputType as GraphQLList<any>).ofType.getFields()).toEqual(
+        {
+            title: expect.objectContaining({
+                type: new GraphQLNonNull(GraphQLString),
+                name: 'title',
+            }),
+            views: expect.objectContaining({
+                type: new GraphQLNonNull(GraphQLInt),
+                name: 'views',
+            }),
+            user_id: expect.objectContaining({
+                type: new GraphQLNonNull(GraphQLID),
+                name: 'user_id',
+            }),
+        }
+    );
 });
 
 test('pluralizes and capitalizes correctly', () => {

src/introspection/getTypeFromValues.spec.ts

@@ -8,6 +8,7 @@ import {
     GraphQLString,
 } from 'graphql';
 import { GraphQLJSON } from 'graphql-type-json';
+import { expect, test } from 'vitest';
 import DateType from './DateType';
 import getTypeFromValues from './getTypeFromValues';
 

src/introspection/getTypesFromData.spec.ts

@@ -5,6 +5,7 @@ import {
     GraphQLInt,
     GraphQLNonNull,
 } from 'graphql';
+import { expect, test } from 'vitest';
 import getTypesFromData from './getTypesFromData';
 
 test('Integration test', () => {

src/introspection/getValuesFromEntities.spec.ts

@@ -1,3 +1,4 @@
+import { expect, test } from 'vitest';
 import getValuesFromEntities from './getValuesFromEntities';
 
 test('does not take empty values into account', () => {
@@ -10,7 +11,7 @@ test('returns an array of values for every field', () => {
         getValuesFromEntities([
             { id: 1, foo: 'bar' },
             { id: 2, foo: 'baz' },
-        ]),
+        ])
     ).toEqual({
         id: [1, 2],
         foo: ['bar', 'baz'],
@@ -27,7 +28,7 @@ test('can handle sparse fieldsets', () => {
             { id: 1, foo: 'foo1' },
             { id: 2, foo: 'foo2', bar: 'bar1' },
             { id: 3, bar: 'bar2' },
-        ]),
+        ])
     ).toEqual({
         id: [1, 2, 3],
         foo: ['foo1', 'foo2'],

src/resolver/Entity/index.spec.ts

@@ -1,3 +1,4 @@
+import { expect, test } from 'vitest';
 import entity from './index';
 
 test('provides empty resolver for data without relationship', () =>

src/resolver/Mutation/create.spec.ts

@@ -1,3 +1,4 @@
+import { expect, test } from 'vitest';
 import create from './create';
 
 test('returns a new object with id 0 on empty datastore', () => {

src/resolver/Mutation/createMany.spec.ts

@@ -1,3 +1,4 @@
+import { expect, test } from 'vitest';
 import createMany from './createMany';
 
 test('returns a new object with id 0 on empty datastore', () => {

src/resolver/Mutation/remove.spec.ts

@@ -1,3 +1,4 @@
+import { expect, test } from 'vitest';
 import remove from './remove';
 
 test('returns undefined by default', () => {