我不断收到这个错误，可能来自typeDefs

import gql from 'graphql-tag';

const typeDefs = gql`
  type CustomerService {
    findAll(): [CustomerEntity]
    findOne(id: String!): CustomerEntity
    createCustomer(input: CreateCustomerInput!): CustomerEntity
    updateCustomer(id: String!, input: UpdateCustomerInput!): CustomerEntity
    deleteCustomer(id: String!): Boolean
  }

  type Query {
    customers: [CustomerEntity]
    customer(id: String!): CustomerEntity
  }

  type Mutation {
    createCustomer(input: CreateCustomerInput!): CustomerEntity
    updateCustomer(id: String!, input: UpdateCustomerInput!): CustomerEntity
    deleteCustomer(id: String!): Boolean
  }

  type CustomerEntity {
    id: String
    name: String
    email: String
  }

  input CreateCustomerInput {
    name: String!
    email: String!
  }

  input UpdateCustomerInput {
    name: String
    email: String
  }
`;

export default typeDefs;

我发球了

import { Injectable } from '@nestjs/common';
import { CustomerEntity } from './entities/customer.entity';
import { CreateCustomerInput } from './dto/create-customer.input';
import { UpdateCustomerInput } from './dto/update-customer.input';
import { Sales } from '../sales/entity/sales.entity';

@Injectable()
export class CustomerService {
  private customers: CustomerEntity[] = [];

  async createCustomer(input: CreateCustomerInput): Promise<CustomerEntity> {
    const customer = new CustomerEntity();
    customer.id = (this.customers.length + 1).toString();
    customer.firstName = input.firstName;
    customer.lastName = input.lastName;
    customer.email = input.email;
    customer.password = input.password;
    customer.sales = [new Sales()];
    this.customers.push(customer);
    return customer;
  }

  async findAll(): Promise<CustomerEntity[]> {
    return this.customers;
  }

  async findOne(id: string): Promise<CustomerEntity> {
    return this.customers.find((customer) => customer.id === id);
  }

  async updateCustomer(
    id: string,
    input: UpdateCustomerInput,
  ): Promise<CustomerEntity> {
    const customerIndex = this.customers.findIndex(
      (customer) => customer.id === id,
    );
    if (customerIndex === -1) {
      throw new Error('Customer not found');
    }

    const customer = this.customers[customerIndex];
    if (input.firstName) {
      customer.firstName = input.firstName;
    }
    if (input.lastName) {
      customer.lastName = input.lastName;
    }
    if (input.email) {
      customer.email = input.email;
    }
    if (input.password) {
      customer.password = input.password;
    }

    this.customers[customerIndex] = customer;
    return customer;
  }

  async deleteCustomer(id: string): Promise<boolean> {
    const customerIndex = this.customers.findIndex(
      (customer) => customer.id === id,
    );
    if (customerIndex === -1) {
      throw new Error('Customer not found');
    }

    this.customers.splice(customerIndex, 1);
    return true;
  }
}

解析器：

/* eslint-disable @typescript-eslint/no-unused-vars */
import { IResolvers } from '@graphql-tools/utils';
import { CustomerService } from './customer.service';

export class CustomerResolver implements IResolvers {
  [key: string]: any;

  constructor(private readonly customerService: CustomerService) {}

  Query = {
    customers: async (root, args, context, info) => {
      return this.customerService.findAll();
    },
    customer: async (root, { id }, context, info) => {
      return this.customerService.findOne(id);
    },
  };

  Mutation = {
    createCustomer: async (root, { input }, context, info) => {
      return this.customerService.createCustomer(input);
    },
    updateCustomer: async (root, { id, input }, context, info) => {
      return this.customerService.updateCustomer(id, input);
    },
    deleteCustomer: async (root, { id }, context, info) => {
      return this.customerService.deleteCustomer(id);
    },
  };
}

我一直收到这个错误：

return new _GraphQLError.GraphQLError(`Syntax Error: ${description}`, {
         ^
GraphQLError: Syntax Error: Expected Name, found ")".