We Keep Coding

NodeJs Cannot Find Module. Path and name are correct

I'm trying to debug a simple error in NodeJs. Error: Cannot find module './schema/schema'.
I tried to create a dummy file with a string and trying to require in my project root and the same error showed up. I tried to delete the folder and the file about 3x and the error persist.
Here is my code:
const express = require('express');
const expressGraphQL = require('express-graphql').graphqlHTTP;
const schema = require('./schema/schema');
const app = express();
app.use('/graphql', expressGraphQL({
schema: schema,
graphiql: true
}));
app.listen(4000, () => {
console.log('Listening');
});
My schema file
const graphql = require('axios');
const axios = require('axios');
const {
GraphQLObjectType,
GraphQLString,
GraphQLInt,
GraphQLSchema,
} = graphql
const CompanyType = new GraphQLObjectType({
name: 'Company',
fields: {
id: { type: GraphQLString },
name: { type: GraphQLString },
description: { type: GraphQLString }
}
});
const UserType = new GraphQLObjectType({
name: 'User',
fields: {
id: { type: GraphQLString},
firstName: { type: GraphQLString },
age: { type: GraphQLInt },
company: {
type: CompanyType,
resolve(parentValue, args) {
axios.get(`http://localhost:3000/companies/${parentValue.companyId}`).then(
(response) => response.data
);
}
}
}
});
const RootQuery = new GraphQLObjectType({
name: 'RootQueryType',
fields: {
user: {
type: UserType,
args: { id: { type: GraphQLString } },
resolve(parentValue, args) {
return axios.get(`http://localhost:3000/users/${args.id}`).then(
(response) => response.data
);
}
},
company: {
type: CompanyType,
args: { id: { type: GraphQLString } },
resolve(parentValue, args) {
return axios.get(`https://localhost:3000/companies/${args.id}`).then(
(response) => response.data
);
}
}
}
});
module.exports = new GraphQLSchema({
query: RootQuery
});
How my project is organised:
I tried to clone this project in another machine and the error persist. Does anyone have a clue about this? There are no typos, no spaces in the file, also I tried to delete node modules and run yarn and no success.

Your files have a .ts extension.
It can't find the file because it doesn't have a .js or .cjs file extension.
If you're using TypeScript, then use:
import/export and not require/modules.exports and
a typescript compiler
If you're not using TypeScript then use a .js file extension.

The correct syntax is:
import sampleModule = require('modulename');
or
import * as sampleModule from 'modulename';
Then compile your TypeScript with --module commonjs.

GraphQL: One of the provided types for building the Schema is missing a name

I'm learning GraphQL so I got a strange issue
I have this code on one file Schema.js:
const graphQL = require('graphql');
const lodash = require('lodash')
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const StatusType = new GraphQLObjectType({
name: 'Status',
fields: () => ({
id: { type: GraphQLInt },
statusName: { type: GraphQLString },
user: {
type: new GraphQLList(UserType),
resolve(parentValue, args){
}
}
})
});
const UserType = new GraphQLObjectType({
name: 'User',
fields: () => ({
id: { type: GraphQLString },
username: { type: GraphQLString },
mail: { type: GraphQLString },
password: { type: GraphQLString },
status: {
type: StatusType,
resolve(parentValue, args){
}
},
})
});
const RouteQuery = new GraphQLObjectType({
name: 'RouteQuery',
user: {
type: UserType,
args: { id: { type: GraphQLString } },
resolve(parentValue, args){
//return lodash.find(users, { id: args.id })
}
},
userSome: {
type: new GraphQLList(UserType),
args: { id: { type: GraphQLString } },
resolve(parentValue, args){
if (args.id) {
//return users.filter(user => user.id === args.id);
}
//return users;
}
},
userAll: {
type: new GraphQLList(UserType),
resolve(parentValue){
//return users
}
},
status:{
type: StatusType,
args: { id: { type: GraphQLInt } },
resolve(parentValue, args){
//return lodash.find(status, { id: args.id })
}
},
statusAll: {
type: new GraphQLList(StatusType),
resolve(parentValue){
//return users
}
}
}
});
module.exports = new GraphQLSchema({
query: RouteQuery
})
This code run succesfully but when i try to separate these into multiple files: the const StatusType & UserType like the following case:
the StatusType is on StatusType.js file and the UserType is on UserType.js file
StatuType.js file:
const graphQL = require('graphql');
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const UserType = require('./UserType')
const StatusType = new GraphQLObjectType({
name: 'Status',
fields: () => ({
id: { type: GraphQLInt },
statusName: { type: GraphQLString },
user: {
type: new GraphQLList(UserType),
resolve(parentValue, args){
//return users.filter(user => user.status === parentValue.id);
}
}
})
});
module.exports = StatusType;
UserType.js file:
const graphQL = require('graphql');
const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLSchema, GraphQLList } = graphQL;
const StatusType = require('./StatusType')
const UserType = new GraphQLObjectType({
name: 'User',
fields: () => ({
id: { type: GraphQLString },
username: { type: GraphQLString },
mail: { type: GraphQLString },
password: { type: GraphQLString },
status: {
type: StatusType,
resolve(parentValue, args){
//return lodash.find(status, { id: parentValue.status })
}
},
})
});
module.exports = UserType;
And on the Schema.js file i include these 2 like that:
const StatusType = require('./StatusType');
const UserType = require('./UserType');
so instead of putting the all code on the same file, i putted the StatusType and UserType on respective files.
but when i run this code, i got this error:
So i don't know what the problem here :/
But when i'm tring to console.log the const UserType = require('./UserType') i got User as response :o like when it was on the same code on Schema.js

You are facing a problem in the way nodeJs handle require. See http://nodejs.org/api/modules.html#modules_cycles for how require is handled in node.
Specifically in your case, when you do:
const StatusType = require('./StatusType');
const UserType = require('./UserType');
StatusType is loaded from const StatusType = require('./StatusType');
StatusType.js loads UserType from const UserType = require('./UserType')
UserType.js should require StatusType but nodeJs prevent this to avoid infinite loop. As a result, it executes next lines
UserType is initialized as new GraphQLObjectType(...) and defined fields as a function. The function closure hand a variable StatusType not yet initialized. It's just an empty exported module {}
You can verify that adding console.log(StatusType); when creating UserType fields:
const UserType = new GraphQLObjectType({
name: 'User',
fields: () => {
console.log(StatusType);
return ({
id: { type: GraphQLString },
username: { type: GraphQLString },
mail: { type: GraphQLString },
password: { type: GraphQLString },
status: {
type: StatusType,
resolve(parentValue, args) {
}
},
});
}
});
You'll get:
{} //instead of StatusType
You didn't encounter this problem when everything was in the same file because both UserType and StatusType are defined within the same closure and now each others.
To resolve that you had to define UserType and StatusType on the same level and inject them. A good example of how to do it can be found here. In your case:
// StatusType.js
const StatusType = (types) => new GraphQLObjectType({
name: 'Status',
fields: () => {
console.log(types.UserType);
return ({
id: { type: GraphQLInt },
statusName: { type: GraphQLString },
user: {
type: new GraphQLList(types.UserType),
resolve(parentValue, args) {
}
}
});
}
});
module.exports = StatusType;
// UserType.js
const UserType = (types) => new GraphQLObjectType({
name: 'User',
fields: () => {
console.log(types.StatusType);
return ({
id: { type: GraphQLString },
username: { type: GraphQLString },
mail: { type: GraphQLString },
password: { type: GraphQLString },
status: {
type: types.StatusType,
resolve(parentValue, args) {
}
},
});
}
});
module.exports = UserType;
// Schema.js
const StatusTypeInject = require('./StatusType');
const UserTypeInject = require('./UserType');
const types = {};
types.StatusType = StatusTypeInject(types);
types.UserType = UserTypeInject(types);
const StatusType = types.StatusType;
const UserType = types.UserType;

You could do with some cleaning up here and here's how I'd resolve these situations:
[..]
// import GraphQLNonNull from the graphql lib
// In your case, I'd use GraphQLID instead of GraphQLString
userSome: {
type: new GraphQLList(require('../path/to/UserType')),
args: { id: { type: new GraphQLNonNull(GraphQLID) } },
resolve: async (parentValue, args) => {
// No need for the if statement as we'd sure to have an id.
// return await filter users by id.
}
},
[..]
And as always, keep your fields as functions: fields: () => ({})

Injection solves this error
// StatusType.js
const StatusType = (types) => new GraphQLObjectType({
name: 'Status',
fields: () => {
console.log(types.UserType);
return ({
id: { type: GraphQLInt },
statusName: { type: GraphQLString },
user: {
type: new GraphQLList(types.UserType),
resolve(parentValue, args) {
}
}
});
}
});
module.exports = StatusType;
Create a types.js file in your directory.
Here you can add all your types that integrate with other types and inject the required types.
const UserTypeInject = require("./UserType");
const StatusTypeInject = require("./Author");
const types = {};
types.UserType = UserTypeInject(types);
types.StatusType = StatusTypeInject(types);
const UserType = types.UserType;
const StatusType = types.StatusType;
module.exports = { UserType, StatusType };
Whenever you need the type either in Mutations or Queries, you import it from the types.js files as such;
const { UserType } = require("../types");

https://i.stack.imgur.com/ORvCG.png
Please see the above Image and code line: 5.
I was inserting data into my client collection using Mutation GraphQL and used a single quote for ClientType ('ClientType') and got the same error. I have just removed a single quote as the type wants the client GraphQLObjectType and I was providing ClientType as String.
I searched for it for 2 days.
Hope it will help anyone.

You are importing UserType inside StatusType before declaration.
const StatusType = require('./StatusType');
const UserType = require('./UserType');

GraphQL cyclical reference using thunks - Error: field type must be Output Type but got: undefined

I have to solve a cyclic definition for GraphQL, but for some reason I´m not being able to solve. I´ve checked several posts about thunks and lazy loading and here is my current code:
History/types.js
const fields = {
id: {
type: new GraphQLNonNull(GraphQLID),
resolve: (obj) => dbIdToNodeId(obj._id, "History")
},
timestamp: {
type: GraphQLLong
},
objectId: {
type: GraphQLString
},
user: {
type: require('../User/connections').default,
args: connectionArgs,
resolve: (source, args) => {
return UserModel.findOne({ id: source.id }).exec();
}
},
action: {
type: new GraphQLNonNull(GraphQLString)
}
};
export const HistoryType = new GraphQLObjectType({
name: 'History',
description: 'History',
interfaces: () => [NodeInterface],
isTypeOf: (value) => value instanceof HistoryModel,
fields: () => (fields)
});
History/connections.js:
import { HistoryType } from './types';
const { connectionType: HistoryConnectionType } = connectionDefinitions( { nodeType: HistoryType });
export default HistoryConnectionType;
User/types.js
const fields = {
id: {
type: new GraphQLNonNull(GraphQLID),
resolve: (obj) => dbIdToNodeId(obj._id, "User")
},
email: {
type: GraphQLString
},
history: {
type: require('../History/connections').default,
args: connectionArgs,
resolve: (source, args, context) => {
return HistoryModel.find({ deleted: false, objectId: source.id}).sort('timestamp').exec();
}
}
};
export const UserType = new GraphQLObjectType({
name: 'User',
description: 'User',
interfaces: () => [NodeInterface],
isTypeOf: (value) => value instanceof UserModel,
fields: () => (fields)
});
User/connections.js
import { UserType } from './types';
const { connectionType: UserConnectionType } = connectionDefinitions( { nodeType: UserType });
export default UserConnectionType;
Company/types.js
const fields = {
id: {
type: new GraphQLNonNull(GraphQLID),
resolve: (obj) => dbIdToNodeId(obj._id, "Company")
},
name: {
type: GraphQLString
},
users: {
type: require('../User/connections').default,
args: connectionArgs,
resolve: (source, args) => {
const { id } = source;
return UserModel.find({ companyId: id }).then((rows) => connectionFromArray(rows,args));
}
},
history: {
type: require('../History/connections').default,
args: connectionArgs,
resolve(source, args, context) {
return loaders.getHistory(source.id);
}
}
};
export const CompanyType = new GraphQLObjectType({
name: 'Company',
description: 'Company',
interfaces: () => [NodeInterface],
isTypeOf: (value) => value instanceof CompanyModel,
fields: () => (fields)
});
Company/connections.js
import { CompanyType } from './types';
const { connectionType: CompanyConnectionType } = connectionDefinitions( { nodeType: CompanyType });
export default CompanyConnectionType;
I can´t make it work. When running I´m getting the following output:
History.user field type must be Output Type but got: undefined

I guess you resolved it by now, but for anyone passing by:
In history/types.js, the fields object must be inlined in the fields function of HistoryType, so it gets created at runtime.
const HistoryType = new GraphQLObjectType({
...
fields: () => ({ ... }), // not a var, object is inlined
...
});

How to add root and viewer queries on an existing GraphQL Server for Relay support

I've been working with GraphQL for a while and was able to successfully launch a simple GraphQL Server. Now I'm trying to make it support Relay, my final goal, and I'm having trouble adding support for the root node query and the viewer query.
I do understand the concept of both node and viewer, but I'm not making it work in the way I've structured my code. Here is my code, organized into separate files:
./graphql/User/types.js
import {
GraphQLObjectType,
GraphQLInputObjectType,
GraphQLNonNull,
GraphQLID,
GraphQLList,
GraphQLString,
GraphQLInt,
GraphQLBoolean
} from 'graphql';
import { GraphQLLong } from '../scalars';
import { NodeInterface } from '../interfaces';
const fields = {
_id: {
type: new GraphQLNonNull(GraphQLID)
},
email: {
type: GraphQLString
},
firstName: {
type: GraphQLString
},
lastName: {
type: GraphQLString
},
jobTitle: {
type: GraphQLString
},
phone: {
type: GraphQLString
}
};
export const UserType = new GraphQLObjectType({
name: 'User',
description: 'User',
interface: NodeInterface,
fields: fields
})
./graphql/User/queries.js
import { GraphQLNonNull, GraphQLID, GraphQLList } from 'graphql';
import { UserType, UserInputType } from './types';
import UserModel from '../../models/User';
const User = {
type: UserType,
description: 'Get single user',
args: {
id: {
name: 'id',
type: new GraphQLNonNull(GraphQLID)
}
},
resolve(root, params) {
params.deleted = false;
return UserModel.find(params).exec();
}
}
const Users = {
type: new GraphQLList(UserType),
description: 'Get all users',
resolve(root) {
const companies = UserModel.find({ deleted: false }).exec();
if (!companies) {
throw new Error('Error getting users.')
}
return companies;
}
}
export default {
User,
Users
}
./graphql/Company/types.js
import {
GraphQLObjectType,
GraphQLInputObjectType,
GraphQLNonNull,
GraphQLID,
GraphQLList,
GraphQLString,
GraphQLInt,
GraphQLBoolean
} from 'graphql';
import { GraphQLLong } from '../scalars';
import { UserType } from '../User/types';
import { NodeInterface } from '../interfaces';
import UserModel from '../../models/User';
const fields = {
_id: {
type: new GraphQLNonNull(GraphQLID)
},
name: {
type: GraphQLString
},
ein: {
type: GraphQLString
},
users: {
type: new GraphQLList(UserType),
resolve(company) {
const { _id } = company;
return UserModel.find({ companyId: _id }).exec();
}
}
};
export const CompanyType = new GraphQLObjectType({
name: 'Company',
description: 'Company',
interface: NodeInterface,
fields: fields
})
./graphql/Company/queries.js
import { GraphQLNonNull, GraphQLID, GraphQLList } from 'graphql';
import { CompanyType, CompanyInputType } from './types';
import CompanyModel from '../../models/Company';
const Company = {
type: CompanyType,
description: 'Get single company',
args: {
id: {
name: 'id',
type: new GraphQLNonNull(GraphQLID)
}
},
resolve(root, params) {
params.deleted = false;
return CompanyModel.find(params).exec();
}
}
const Companies = {
type: new GraphQLList(CompanyType),
description: 'Get all companies',
resolve(root) {
const companies = CompanyModel.find({ deleted: false }).exec();
if (!companies) {
throw new Error('Error getting companies.')
}
return companies;
}
}
export default {
Company,
Companies
}
./graphql/interfaces.js
import {
GraphQLInterfaceType,
GraphQLNonNull,
GraphQLID
} from 'graphql';
const NodeInterface = new GraphQLInterfaceType({
name: 'Node',
fields: {
id: {
type: new GraphQLNonNull(GraphQLID)
}
},
resolveType: (source) => {
return source.__type;
}
});
export default NodeInterface;
./graphql/schema.js
import { GraphQLObjectType, GraphQLSchema } from 'graphql';
import queries from './queries';
import mutations from './mutations';
export default new GraphQLSchema({
query: new GraphQLObjectType({
name: 'Query',
fields: queries
}),
mutation: new GraphQLObjectType({
name: 'Mutation',
fields: mutations
})
});
./graphql/queries.js
import {
GraphQLObjectType,
GraphQLNonNull,
GraphQLID
} from 'graphql';
import { NodeInterface } from './interfaces';
import CompanyQueries from './Company/queries';
import UserQueries from './User/queries';
const RootQuery = new GraphQLObjectType({
name: 'RootQuery',
description: 'The root query',
fields: {
viewer: {
type: NodeInterface,
resolve(source, args, context) {
return { result: "VIEWER!" };
}
},
node: {
type: NodeInterface,
args: {
id: {
type: new GraphQLNonNull(GraphQLID)
}
},
resolve(source, args, context, info) {
return { result: "NODE QUERY" };
}
}
}
});
export default {
RootQuery,
...CompanyQueries,
...UserQueries
}
./server.js
import express from 'express';
import bodyParser from 'body-parser';
import mongoose from 'mongoose';
import morgan from 'morgan';
import graphqlHTTP from 'express-graphql';
import schema from './graphql/schema';
// set up example server
const app = express();
app.set('port', (process.env.API_PORT || 3001));
// logger
app.use(morgan('dev'));
// parse body
app.use(bodyParser.json());
app.use('/graphql', graphqlHTTP({
schema: schema,
graphiql: true,
pretty: true
}));
const mongoUri = process.env.MONGO_URI || 'mongodb://localhost/testdb';
mongoose.set('debug', true);
mongoose.connect(mongoUri, {
useMongoClient: true,
});
export default app;
The RootQuery is not being added to Schema. In fact I'm getting this error:
Error: Query.RootQuery field type must be Output Type but got: undefined.
Conceptually I don't know how to fix this code:
a) I don't know how to add that RootQuery to my query, and I don't know if I need to keep my other queries to my server (as Relay basically relies on node queries).
b) I cannot also see how my RootQuery will discover the object type and return it at the return source.__type. I've added that piece of code but I don't know how or where the given type will fill up this field.
Although I'm understanding a little of GraphQL, it seems that I don't have yet the fundamentals on how to build the Relay required root query (not to talk about the paginators, but this is my next step once I solve that).

The problem appears to be
import queries from './queries';
new GraphQLObjectType({
name: 'Query',
fields: queries
}),
const RootQuery = new GraphQLObjectType({
…
});
export default {
RootQuery,
…
};
The queries that you pass as the fields for the Query type is an object of types, not an object of field configurations. They are missing type and resolve properties, as the error message complains.

GraphQL/Relay Schema "Cannot query field..."

I'm having a problem with querying some fields in graphql/relay.
I'm trying to query the "courseName" field on Courses in the schema below.
If I query the User with for example:
{ user(id:1){firstname,lastname}}
It works and returns the correct response.
Here is my schema:
import {
GraphQLBoolean,
GraphQLFloat,
GraphQLID,
GraphQLInt,
GraphQLList,
GraphQLNonNull,
GraphQLObjectType,
GraphQLSchema,
GraphQLString,
} from 'graphql';
import {
connectionArgs,
connectionDefinitions,
connectionFromArray,
fromGlobalId,
globalIdField,
mutationWithClientMutationId,
nodeDefinitions,
} from 'graphql-relay';
import {
// Import methods that your schema can use to interact with your database
User,
Course,
getUser,
getCourses
} from './database';
/**
* We get the node interface and field from the Relay library.
*
* The first method defines the way we resolve an ID to its object.
* The second defines the way we resolve an object to its GraphQL type.
*/
var {nodeInterface, nodeField} = nodeDefinitions(
(globalId) => {
var {type, id} = fromGlobalId(globalId);
if (type === 'User') {
return getUser(id);
} else if (type === 'Course') {
return getCourses(id);
} else {
return null;
}
},
(obj) => {
if (obj instanceof User) {
return userType;
} else if (obj instanceof Course) {
return courseType;
} else {
return null;
}
}
);
/**
* Define your own types here
*/
var userType = new GraphQLObjectType({
name: 'User',
description: 'A person who uses our app',
fields: () => ({
id: globalIdField('User'),
firstname : {
type : GraphQLString,
description : 'User First Name'
},
lastname :{
type : GraphQLString,
description : 'User Last Name'
},
email : {
type : GraphQLString,
description : 'User email'
},
company : {
type : GraphQLString,
description : 'User company'
},
courses: {
type: courseConnection,
description: 'A user\'s collection of courses',
// args: {
// userId: {
// type: GraphQLInt
// }
// },
// resolve: (user, args) => connectionFromArray(getCourses(args.userId), args),
args: connectionArgs,
resolve: (user, args) => connectionFromArray(
getCourses(user.id),
args
)
},
}),
interfaces: [nodeInterface],
});
var courseType = new GraphQLObjectType({
name: 'Course',
description: 'A shiny course',
fields: () => ({
id: globalIdField('Course'),
courseName: {
type: GraphQLString,
description: 'The name of the Course',
}
}),
interfaces: [nodeInterface],
});
/**
* Define your own connection types here
*/
var {connectionType: courseConnection} =
connectionDefinitions({name: 'Course', nodeType: courseType});
/**
* This is the type that will be the root of our query,
* and the entry point into our schema.
*/
var queryType = new GraphQLObjectType({
name: 'Query',
fields: () => ({
node: nodeField,
// Add your own root fields here
user: {
type: userType,
args: {
id: { type: GraphQLInt }
},
resolve: (_,{id}) => getUser(id)
}
})
});
/**
* This is the type that will be the root of our mutations,
* and the entry point into performing writes in our schema.
*/
var mutationType = new GraphQLObjectType({
name: 'Mutation',
fields: () => ({
// Add your own mutations here
})
});
/**
* Finally, we construct our schema (whose starting query type is the query
* type we defined above) and export it.
*/
export var Schema = new GraphQLSchema({
query: queryType,
// Uncomment the following after adding some mutation fields:
// mutation: mutationType
});
here is my database.js:
import Course from './models/course';
import User from './models/user';
module.exports = {
User : User,
// Export methods that your schema can use to interact with your database
getUser: (id) => {
return User.findOne( {_id: id}).exec();
},
getCourses: (userId) => {
return Course.find( { userId : userId }).exec();
},
Course : Course
// getCourse: (id) => widgets.find(w => w.id === id),
// User,
// Widget,
};
When I try to query for:
{ user (id:1){courses{courseName}} }
It gives me the error:
"Cannot query field 'courseName' in 'CourseConnection'"
It seems that it is a problem with the connection.
Also I'm testing this queries with cURL. Since I want to test the schema before moving to react/relay.
What am I missing?
Thank you.

So, I found out why this was not working.
I had to do the query in RelayJS style:
so:
{ user(id:1){courses(first:2){edges{node{courseName}}}} }