graphql-yoga: When use string file path for typeDefs,there is a error: Cannot parse the unexpected character "/".

Same here… that’s strange. Maybe node version related. I worked around it by reading file contents and passing it to typedefs option, as if it was inlined in the code. Also I’m using “.graphqls” etension.

const typeDefs = fs.readFileSync('./src/schema.graphqls','utf8');
...
const server = new GraphQLServer({
  typeDefs,
  resolvers
});

I suspect it’s failing to reconize the argument as as filepath for some reason, so it tries to parse the path as actual graphql schema. Not why this happens though, I tried the same path for both fs.readFileSync and typeDefs option. I also tried the full path, but no luck either.

I am having the same issue… has anyone figured it out?

Hello, new to GraphQL but was able to figure this out.

Basically, I had a javascript syntax comment on schema.graphql file:

// server/src/schema.graphql

type Query {
...

Once I removed the comment, the error was gone. I guess the // threw it off!

I solved it !!. My editor is webstorm and uses graphql plugin. it makes the extension for the schema with (graphqls) with change the extension to (graphql) works fine now. @Shaderzero thanks for your attention.

@AmrAlmagic Problem is not in code for typeDefs: './src/graph.graphql' for GraphQLServer important to have proper schema description in this file my current index,js

import {GraphQLServer, PubSub} from "graphql-yoga";
import db from './db';
import Comment from './resolvers/comment';
import Mutation from './resolvers/mutation';
import Subscription from './resolvers/subscription';
import Post from './resolvers/post';
import Query from './resolvers/query';
import User from './resolvers/user';

const pubsub = new PubSub();

const server = new GraphQLServer({
  typeDefs: './src/schema.graphql',
  resolvers: {
    Comment,
    Mutation,
    Subscription,
    Post,
    Query,
    User
  },
  context: {
    db,
    pubsub
  }
});

server.start(() => {
  console.log('the server is up')
})

and schema.graphql

schema {
    query: Query
    mutation: Mutation
}

type Query {
    users(query: String): [User!]!
    posts(query: String): [Post!]!
    me: User!
    post: Post!
    comments: [Comment!]!
}

type Mutation {
    createUser(data: CreateUserInput!): User!
    deleteUser(id: ID!): User!
    updateUser(id: ID!, data: UpdateUserInput!): User!
    createPost(data: CreatePostInput!): Post!
    deletePost(id: ID!): Post!
    updatePost(id: ID!, data: UpdatePostInput!): Post!
    createComment(data: CreateCommentInput!): Comment!
    deleteComment(id: ID!): Comment!
    updateComment(id: ID!, data: UpdateCommentInput!): Comment!
}

type Subscription {
    comment(postId: ID!): CommentSubscriptionPayload!
    post: PostSubscriptionPayload!
}

input CreateUserInput {
    name: String!
    email: String!
    age: Int
}

input UpdateUserInput {
    name: String
    email: String
    age: Int
}

input CreatePostInput {
    title: String!
    body: String!
    published: Boolean!
    author: ID!
}

input UpdatePostInput {
    title: String
    body: String
    published: Boolean
}

input CreateCommentInput {
    text: String!
    author: ID!
    post: ID!
}

input UpdateCommentInput {
    text: String
}

type User {
    id: ID!
    name: String!
    email: String!
    age: Int,
    posts: [Post!]!
    comments: [Comment!]!
}

type Post {
    id: ID!
    title: String!
    body: String!
    published: Boolean!
    author: User!
    comments: [Comment!]!
}

type Comment {
    id: ID!
    text: String!
    author: User!
    post: Post!
}

enum MutationType {
    CREATED
    UPDATED
    DELETED
}

type PostSubscriptionPayload {
    mutation: MutationType!
    data: Post!
}

type CommentSubscriptionPayload {
    mutation: MutationType!
    data: Comment!
}