.../node_modules/graphql/error/sytnaxError.js `return new _G

Question

我正在启动Reactjs项目的Apollo/GraphQL后端。我仍处于早期阶段(对这种后端工作相对较新，所以请与我一起讨论(，只是试图让一切都进入一种状态，在这种状态下我可以成功运行node server.js并使后端旋转。我一直在运行它，遇到了一个错误，并修复了好几轮，但我现在遇到的错误基本上没有帮助我去哪里寻找或确切地寻找什么。运行node server.js后，我得到了此响应。。。

/Users/nickfatherbool/code/personal/finance/value_tracker/backend/node_modules/graphql/error/syntaxError.js:15
return new _GraphQLError.GraphQLError(

GraphQLError: Syntax Error: Expected Name, found "}".
at syntaxError (/Users/nickfatherbool/code/personal/finance/value_tracker/backend/node_modules/graphql/error/syntaxError.js:15:10)

我试着用Ctrl + F来查找行return new _GraphQLError.GraphQLError(，但找不到类似的内容。我敢肯定，在node-modules目录中挖掘会浪费时间，因为很少有这样的答案，而且我尝试删除该目录并再次运行npm i，所以我怀疑我是否可以修复其中的任何内容。目前，我的server.js文件是这样构建的…

import express from 'express'
import cors from 'cors'
import dotenv from 'dotenv'
import { ApolloServer } from 'apollo-server-express'
import typeDefs from './graphql/typeDefs.js';
import resolvers from './graphql/resolvers/index.js';
import util from 'util'

dotenv.config();
const startApolloServer = async () => {
const app = express()
const server = new ApolloServer({
typeDefs,
resolvers,
context: ({req}) => ({req})
})
const whitelist = [
"http://localhost:3000",
"http://localhost:4000/graphql",        
"https://studio.apollographql.com",
]
app.use(cors({ /* credentials: true, */ origin: "*" })); 
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get('/', (req, res) => {
res.send('Welcome to SQL');
});
await server.start()
await server.applyMiddleware({ app, path: '/graphql', cors: false });
await app.listen(process.env.PORT, () => console.log(`Server running on ${process.env.PORT}... GraphQL/Apollo at studio.apollographql.com/dev`));
}
startApolloServer()

我的prisma.schema和typeDefs.js文件都设置好了。。。如果需要，我可以附上它们，但我很确定它们与手头的问题无关。有人知道哪里出了问题吗，或者对我应该在哪里寻找答案有什么建议吗？

这些是迄今为止唯一的突变/查询。。。

import bcrypt from 'bcryptjs';
import generateToken from '../../utils/generateToken.js';
import { UserInputError } from 'apollo-server-errors';
import checkGlobalAuth from '../../utils/checkAuthorization/checkGlobalAuth.js';
import db from '../../utils/generatePrisma.js';
import hashPassword from '../../utils/passwordHasher.js';
import { validateRegisterInput } from '../../utils/validators.js';
import { checkExistingUserByEmail, checkExistingUserByPhone } from '../../utils/checkExisting.js';

export default {
Query: {
getUser: async (_, { }, context) => {
const user = await checkGlobalAuth(context)
try {
return await db.user.findUnique({
where: {
id: user.id
},
include: {
stocks: true
}
})
} catch(error){
throw new Error(error)
}
}
},
Mutation: {
user_signUp: async (_, { fullname, email, password, phoneNumber } ) => {
try {
// This creates TWO consts -- valid AND errors based off of validateRegisterInput's returns. Look at 
// utils/validators to see what ther validateRegisterInput does    
const {
valid,   // True or False
errors   // Object that has subobjects for potential email / password / fullname errors
} = validateRegisterInput(
email,
password,
fullname
);
// Makes the email in all caps for storage/comparison reasons
email = await email.toUppeCase()
// Checks to make sure all inputs were properly filled
if (!valid) {
throw new userInputError('Errors', {
errors
});
}
// Imported function. Checks duplicate enails
let existingUser =  await checkExistingUserByEmail(email)
if (existingUser) {
throw new UserInputError('email is taken', {
errors: {
email: 'Email is already taken!',
},
});
}
// Import function. Checks duplicate phoneNumbers
existingUser = await checkExistingUserByPhone(phoneNumber)
if (existingUser) {
throw new UserInputError('email is taken', {
errors: {
phoneNumber: 'Phone Number is already in use!',
},
});
}
// Imported function. Hashes password
password = await hashPassword(password)
// Creates a User Account
let user =  await db.user.create({
data: {
name: fullname,
email: email,
password: password,
phoneNumber: phoneNumber
}
})
// Imported function. Generates session token
token = await generateToken(user.id)

// Returns the created User with a session token
return {...user, token: token}

} catch(error){ 
console.loig(error)
throw new Error(error)
}
} 
}
}

我播放的其他文件只有我的typeDefs和prisma.schema文件，它们分别看起来像…

import { gql } from 'apollo-server';
const typeDefs = gql`
scalar Date
scalar JSON
type User{
id:                 ID
username:           String  
password:           String
email:              String
TD_userName:        String  
TD_password:        String
stocks:             [Stock]
emailList:          [JSON]
buySellList:        [JSON]
tradeHistory:       [JSON]
}
type Stock{
id:                 ID
name:               String
ticker:             String
lastValue:          JSON
valueHistory:       JSON
growthExpected:     Int 
growthSoFar:        Int 
growthRatio:        Int
users:              [User]
link:               String
}

type Query {
}
type Mutation {
}

`
export default typeDefs

这是prisma.schema

generator client {
provider      = "prisma-client-js"
binaryTargets = ["native"]
}
datasource db {
provider = "postgresql"
url      = env("DATABASE_URL")
}
model User {
// BASIC INFORMATION
id            Int             @id@default(autoincrement())
username      String          @unique
passsword     String          
email         String
phoneNumber   String          @unique
// BANKING INFORMATION
TD_userName   String          @unique
TD_password   String
// FUNCTIONAL INFORMATION
emailList     Json[]
buySellList   Json[]
tradeHistory  Json[]
// CONNECTIONS
stocks        Stock[]
}
model Stock {
// BASIC INFORMATION
id              Int             @id@default(autoincrement())
name            String          @unique
ticker          String          @unique
// STATISTICAL AND HISTORICAL DATA
lastValue       Json
valueHistory    Json[]
growthExpected  Int
growthSoFar     Int
growthRatio     Int
// CONNECTIONS
users           User[]
link            String
}

Answer 1

这只是一个愚蠢的sytnax错误。我需要在typeDef文件中包含type Mutation { ... }和type Query{ ... }，否则我会收到一些错误，让我知道Query和Mutation是在解析器中定义的，而不是在模式中定义的。添加这些类型修复了这个错误，但由于它们是空对象，因此存在语法错误。