I was toying with federation support and going about it the manual way.

Here's the issue I also posted on apollo-server https://github.com/apollographql/apollo-server/issues/2965

This doesn't work but if you look at the test, it shows the federated schema.

I sort of am clueless on how to support directives so it'd be cool if someone could chime in on this.

I was mocking the test case from the federation-demo's reviews service. Ideally we can have a fully functional replica.

/cc @JacksonKearl

Hello, I have the following schema:

@ObjectType()
class Action {
  @Field(type => Skill, { nullable: true })
  skill?: Skill;
}

@ObjectType()
export class ActionResult {
  @Field(type => [Action])
  actions!: Action[];
  @Field({ nullable: true })
  count?: number
}

@ObjectType()
export class Skill {}

@Resolver(Action)
export class ActionResolver  extends BaseResolver {
  @Query(returns => ActionResult)
  async actions (@Args() args: ActionArgs, @Info() info){

  }

  @FieldResolver()
  async skill(@Root() action: Action) {
  }
}

@Resolver(Skill)
export class SkillResolver extends BaseResolver {
  @Query(returns => [Skill])
  async allSkills (){

  }
}

From this I generate a schema like this:

  return buildSchema({
    resolvers: [ActionResolver, SkillResolver],
    emitSchemaFile: { path: 'schema.graphql' },
  })

And I get the error:

UnhandledPromiseRejectionWarning: Error: Schema must contain uniquely named types but contains multiple types named "Skill".

Hey @19majkel94 I am trying to use typegoose with type-graphql. Following are the relevant code snippets from my user.model.ts, user.service.ts and user.resolver.ts files. user.model.ts

@ObjectType()
@pre<User>('save', async function () {
  var user = this;
  if (user.isModified('password')) {
    user.password = await bcrypt.hash(user.password, SALT_WORK_FACTOR)
  }
})
export class User extends Typegoose {
  @Field(() => ID)
  _id: string;
  
  @Field(() => Date)
  createdAt: Date;

  @Field(() => Date)
  updatedAt: Date;

  @prop({ required: true })
  @Field(() => String, { nullable: false })
  firstName: string;


  @prop({ required: true })
  @Field(() => String, { nullable: false })
  lastName: string;

  @Field(() => String, { nullable: false })
  @prop({ required: true })
  email: string;

  @prop({ required: true })
  password: string;
}

export const UserModel = new User().getModelForClass(User, { schemaOptions: { timestamps: true } });

user.service.ts

import { UserModel, User } from '../models/user.model';

export const getUserById = async (userId: string): Promise<User> => {
  const user: User = await UserModel.findOne({ _id: userId });
  if (!user) {
    throw new UserInputError(`User with userId ${userId} not found`);
  }
  user.password = null;
  delete user.password;
  return user;
};

user.resolver.ts

import { User } from '../models/user.model';
import { getUserById } from '../services/user.service';

@Resolver(() => User)
export class UserResolver {
  @Query(() => User, { nullable: false })
  @UseMiddleware(Auth)
  async user(@Arg('_id') _id: string, @Ctx() context: Context): Promise<User> {
    return getUserById( _id);
  }
 }

Whenever I try to fire the user resolver I get the following error

{
  "data": null,
  "errors": [
    {
      "message": "Expected value of type \"User\" but got: { _id: 5b530bec3b461c03cef31a53,\n  firstName: 'Danny',\n  lastName: 'Paul',\n  email: '[email protected]',\n  password: null,\n  createdAt: 2018-07-21T10:33:26.763Z,\n  updatedAt: 2018-07-21T10:33:26.763Z,\n  __v: 0 }.",
      "locations": [
        {
          "line": 9,
          "column": 3
        }
      ],
      "path": [
        "user"
      ],
      "extensions": {
        "code": "INTERNAL_SERVER_ERROR",
        "exception": {
          "message": "Expected value of type \"User\" but got: { _id: 5b530bec3b461c03cef31a53,\n  firstName: 'Danny',\n  lastName: 'Paul',\n  email: '[email protected]',\n  password: null,\n  createdAt: 2018-07-21T10:33:26.763Z,\n  updatedAt: 2018-07-21T10:33:26.763Z,\n  __v: 0 }.",
          "locations": [
            {
              "line": 9,
              "column": 3
            }
          ],
          "stacktrace": [
            "GraphQLError: Expected value of type \"User\" but got: { _id: 5b530bec3b461c03cef31a53,",
            "  firstName: 'Danny',",
            "  lastName: 'Paul',",
            "  email: '[email protected]',",
            "  password: null,",
            "  createdAt: 2018-07-21T10:33:26.763Z,",
            "  updatedAt: 2018-07-21T10:33:26.763Z,",
            "  __v: 0 }.",
            "    at invalidReturnTypeError (/usr/src/app/node_modules/graphql/execution/execute.js:766:10)",
            "    at completeObjectValue (/usr/src/app/node_modules/graphql/execution/execute.js:758:13)",
            "    at completeValue (/usr/src/app/node_modules/graphql/execution/execute.js:660:12)",
            "    at completeValue (/usr/src/app/node_modules/graphql/execution/execute.js:629:21)",
            "    at /usr/src/app/node_modules/graphql/execution/execute.js:617:14",
            "    at process._tickCallback (internal/process/next_tick.js:68:7)"
          ]
        }
      }
    }
  ]
}

My package versions are as follows: apollo-server: 2.0.0 apollo-server-express: 2.0.0 mongoose: 5.2.4 type-graphql: 0.12.3 typegoose: 5.2.1

I am sorry I had to post this issue in github and not gitter because of the size of my code.

Describe the bug I installed express-graphql and typed-graphql, then I defined my entities and built the schema, when I pass the Schema to express-graphql and added it to my express app. As soon as I open grahpiql in my browser and run a query I get the error:

{
  "errors": [
    {
      "message": "Cannot use GraphQLSchema \"[object Object]\" from another module or realm.\n\nEnsure that there is only one instance of \"graphql\" in the node_modules\ndirectory. If different versions of \"graphql\" are the dependencies of other\nrelied on modules, use \"resolutions\" to ensure only one version is installed.\n\nhttps://yarnpkg.com/en/docs/selective-version-resolutions\n\nDuplicate \"graphql\" modules cannot be used at the same time since different\nversions may have different capabilities and behavior. The data from one\nversion used in the function from another could produce confusing and\nspurious results."
    }
  ]
}

Enviorment (please complete the following information):

• OS: Ubuntu 18.04
• Node 10.9.0
• Package version 0.13.1
• TypeScript version 3.0.1

How would I use this library in a lambda execution model?

I tried to implement it as follows, but on the second (and subsequent) calls to the endpoint, I get an error which states:

Schema must contain unique named types but contains multiple types named "Person"

I assume that this is because the schema is being re-built on every request, and therefore creating duplicated types?

handler.ts

import 'reflect-metadata';

import { graphqlLambda } from 'apollo-server-lambda';
import { buildSchema } from 'type-graphql';

import { PeopleController } from './controllers/people/peopleController';

export async function graphqlHandler(event, context, callback) {
    function callbackWithHeaders(error, output) {
        output.headers['Access-Control-Allow-Origin'] = '*';
        callback(error, output);
    }

    const schema = await buildSchema({
        resolvers: [PeopleController]
    });

    const handler = graphqlLambda({ schema: schema });
    return handler(event, context, callbackWithHeaders);
}

person.ts:

import { ID, Field, ObjectType } from 'type-graphql';

@ObjectType()
export class Person {
    @Field() name: string;
    @Field() creationDate: Date;
}

peopleController.ts

import { Arg, Query, Resolver } from 'type-graphql';
import { Person } from './person';

@Resolver()
export class PeopleController {
    items: Person[] = [
        {
            name: 'darbio',
            creationDate: new Date()
        }
    ];

    @Query(returns => [Person], { description: 'Get all the people' })
    async people(): Promise<Person[]> {
        return await this.items;
    }
}

Does type-graphql support client side resolvers for use with apollo-link-state? (https://blog.apollographql.com/the-future-of-state-management-dd410864cae2, https://hackernoon.com/storing-local-state-in-react-with-apollo-link-state-738f6ca45569)

Describe the bug When having nested input types only the top-most class gets transformed into it's instance. Any nested objects remains plain javascript objects.

To Reproduce

@InputType()
class NestedTestInputType {
  @Field()
  foo: number
}

@InputType()
class TestInputType {
  @Field()
  nested: NestedTestInputType
}

@Service()
@Resolver(of => /* ... */)
export class TestResolver {
   @Query(returns => [String])
  async test(@Arg('filter') filter: TestInputType) {
    assert(filter instanceof TestInputType, 'Filter must be instance of TestInputType') // <-- OK
    assert(
      filter.nested instanceof NestedTestInputType,
      'Filter#nested must be instance of NestedInputType',
    ) // <-- FAILS
    return []
  }
}

Expected behavior Nested input types should be deserialized into instances of their classes recursively.

Enviorment (please complete the following information):

• [email protected]

The project I'm working on right now has a lot of super-similar CRUD-alike resolvers, and amount of copy-paste is huge. I've come up with something like this:

export type ResourceRepositoryServiceClass<
  TService extends ResourceRepositoryService<TEntity, TId, TContent>,
  TEntity = {},
  TId = {},
  TContent = {}
> = Function & { prototype: TService }

export interface DtoClassType<TDto extends Dto<TDto, TObject>, TObject = {}> {
  new (): TDto
}

export function ResourceResolver<
  TDto extends Dto<TDto, TObject>,
  TContentDto extends Dto<TContentDto, TContentObject>,
  TService extends ResourceRepositoryService<TEntity, TId, TContent>,
  TEntity = {},
  TId = {},
  TContent = {},
  TObject = {},
  TContentObject = {}
> (
  resourceType: Resource,
  resourceServiceIdentifier: ResourceRepositoryServiceClass<TService>,
  dtoClass: DtoClassType<TDto>,
  contentDtoClass: DtoClassType<TContentDto>
) {
  const resourceNameUpper = upperFirst(camelCase(resourceType))

  abstract class ResourceResolver<
    TResolver
  > {
    protected readonly packDto = Dto.pack.bind(dtoClass)
    protected readonly unpackDto = Dto.unpack.bind(dtoClass)
    protected readonly packContentDto = Dto.pack.bind(contentDtoClass)
    protected readonly unpackContentDto = Dto.unpack.bind(contentDtoClass)

    constructor (
      @inject(resourceServiceIdentifier) protected readonly resourceService: TService
    ) {}

    @Mutation(returns => dtoClass)
    @Authorized(Permissions.canCreate(resourceType))
    async [`create${resourceNameUpper}`] (
      @Arg('data', type => contentDtoClass) data: TContentDto
    ): Promise<TDto> {
      const resource = await this.resourceService.create(this.unpackContentDto(data))
      return this.packDto(resource)
    }
  }

  return ResourceResolver
}

@injectable()
@Resolver(of => ThingDto)
export default class ThingResolver extends ResourceResolver(
  Resource.Thing,
  ThingService,
  ThingDto,
  ThingContentDto
)<ThingResolver> {
  constructor (
    @inject(ThingService) thingService: ThingService
  ) {
    super(thingService)
  }

  // Here goes any resource-specific thing
}

Yet the approach won't work, since @Mutation gets a ResourceResolver as target, that can not be resolved via DI.

What are your thoughts on making this approach possible? Options I see so far:

• Resolver should support something like "extends" to override the target of inherited annotations?

It is generally useful to be able to annotate fields with custom metadata for use by middleware and validators. See: #77 and #36 (my personal use case)

Since there currently isn't support for directives in GraphQL-js, an alternative might be for TypeGraphQL to add a new decorator that annotates the fiend config object passed into the GraphQLObjectType constructor with additional user-defined metadata fields.

I'd imagine the API looking something like this:

@ObjectType()
class MyObjectType {
  @Metadata({ isUseful: false })
  @Field()
  myAnnotatedField() {
    return "12"
  }
}

This relatively simple change would make it possible to write middleware libraries wrapping tools such as graphql-query-complexity.

Owner note: Read more about how to implement here: https://github.com/19majkel94/type-graphql/issues/124#issuecomment-426935908

Today, I released the first Release Candidate version of major 1.0.0 🎉 https://www.npmjs.com/package/type-graphql/v/1.0.0-rc.1 It is also distributed as a new major version on the default latest tag.

This release contains a lot of breaking changes, so please read the release notes carefully 👀 https://github.com/MichalLytek/type-graphql/releases/tag/v1.0.0-rc.1

The 1.0.0 milestone is finished in 97% - it contains of 87 closed issues! 😵 https://github.com/MichalLytek/type-graphql/milestone/3 The work that has to be also done before final release is to write the announcement post about the 1.0.0 release, after 2 years of developing TypeGraphQL ☺️

Feel free to update your apps and let me know how the new version works for you and what improvements you would like to see in the upcoming 1.0.0 release!

And don't forget to support the project as its ongoing development is possible only thanks to the support by the community ❤️

Especially if you are using it commercially - just to ensure that the project which your product relies on is actively maintained and improved 💪

Describe the bug Given an InputType field with validation

@InputType()
export class CatalogInput implements Partial<Catalog> {
  @Field()
  id: number;
  @MaxLength(1000)
  @Field({ nullable: true })
  description?: string;
}

and a mutation

@Mutation(returns => CatalogUpdateResult)
updateCatalog(
  @Arg("catalog", () => CatalogInput, { validate: true })
  catalog: CatalogInput
): CatalogUpdateResult {
  return { catalog };
}

when I try to sent mutation to the server with a value exceeding the limit, then I get a very generic error that does not indicate which field caused it, the locations array is empty:

{
  "errors": [
    {
      "message": "Argument Validation Error",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": [
        "updateCatalog"
      ],
      "extensions": {
        "code": "INTERNAL_SERVER_ERROR",
        "exception": {
          "errors": [
            {
              "message": "Argument Validation Error",
              "locations": [],
              "path": [
                "updateCatalog"
              ]
            }
          ],
 ...

Expected behavior I would expected to have the information about what caused the failure, i.e. the location array containing the information.

Enviorment (please complete the following information):

• OS: Windows
• Node 10.15.3
• Package version 0.17.1
• TypeScript version 3.3.3333

Thanks, Karel

This PR starts a series of iterations for improving the maintainability of the project and trying not to create too many conflicts with new-major-release branch. Note that this PR is not ready to be merged (as written before) because the code style must be applied to the new code present in new-major-release branch and not the master since it can create too many conflicts. Should fix #1106 and create a base for a better coding experience! What has been changed:

1. Updated husky configuration to reflect new version.
2. Updated lint-staged configuration (replacing TSLint with ESLint) and moved to a proper configuration file.
3. Updated VS Code settings settings.json to include formatOnSave and defaultFormatter (prettier).
4. Added VS Code extensions.json which includes a list of recommended extensions to install for improving experience while coding in VS Code (help new contributors with their first contribution).
5. Updated benchmarks to match ESLint code style.
6. Moved publish-website.sh to scripts directory. publish-website.sh is POSIX-compliant. scripts include a __commons.sh file (sourced by publish-website.sh) with utility functions (e.g., logger) and more.
7. Replaced TSLint with ESLint. This has been long awaited! The configuration file must be changed to reflect what @MichalLytek desiders (currently is based on Airbnb code style).
8. Added markdownlint: A Node.js style checker and lint tool for Markdown/CommonMark files.
9. Added ShellCheck: A shell script static analysis tool. FUTURE: Add action-shellcheck in CI.
10. Added CSpell: A Spell Checker for Code! to check for typo(s) and spell checking errors.
11. Updated Jest configuration file to match ts-jest. Moreover, type checking and hints in the configuration file
12. Added more scripts in package.json for checking and fixing errors.

@MichalLytek Let me know what you think and what you want to change/update/add/delete.

PS: Do we really need Gulp?

Describe the issue I have a project using DI with tsyringe and i should to add graphql using type-graphql, but in documentation is only listed the TypeDI as a dependency injection lib

Are you able to make a PR that fix this? If is possible to use Tsyringe, plesse add some example in doc's

Additional context N/A

Describe the Bug I'm using type-graphql v2.0.0-beta.1 together with @[email protected]. (As mentioned here type-graphql v1.1.1 doesn't work fine with apollo-server v4) There are some issues related to validation:

1. I'm not able to call a mutation passing correct variables in the body, it leads to Argument Validation Error in the response. The issue seems to be related to "forbidUnknownValues" option in the class-validator library, at least setting it to false allows to avoid the error.

2. The"validationErrors" field is always missing in the ArgumentValidationError response (even if I set forbidUnknownValues to false, add some validator like MaxLength and pass incorrect value - "validationErrors" will be missing in the response JSON)

To Reproduce Here is the code:

import "reflect-metadata";
import { ApolloServer } from "@apollo/server";
import express from "express";
import { expressMiddleware } from "@apollo/server/express4"
import cors from "cors";
import http from "http";
import { ApolloServerPluginDrainHttpServer } from "@apollo/server/plugin/drainHttpServer";
import bodyParser from "body-parser";
import { buildSchema } from "type-graphql";
import { Arg, Mutation, Query, Resolver } from "type-graphql";
import { ObjectType, Field, ID, InputType } from "type-graphql";

@ObjectType()
export class User {
    @Field(() => ID)
    id: string;

    @Field()
    email: string;

    @Field({nullable: true})
    firstName?: string;

    @Field({nullable: true})
    lastName?: string;
}

@InputType()
export class AddUserInput {
    @Field()
    email: string;

    @Field({nullable: true})
    firstName?: string;

    @Field({nullable: true})
    lastName?: string;
}

@Resolver(User)
export class UserResolver {
    users: User[] = [];

    @Query(() => [User], { name: "users" })
    getAll(): User[] {
        return this.users;
    }

    @Mutation(() => User, { name: "addUser" })
    add(@Arg("user") userInput: AddUserInput): User {
        const user = new User();
        Object.assign(user, userInput);
        user.id = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString();
        this.users.push(user);
        return user;
    }
}

const bootstrap = async () => {
    const app = express();
    const httpServer = http.createServer(app);

    const schema = await buildSchema({
        resolvers: [UserResolver],
        //validate: {
        //    forbidUnknownValues: false  !!! Only works with this setting
        //}
    });

    const apolloServer = new ApolloServer({
        schema,
        plugins: [ApolloServerPluginDrainHttpServer({ httpServer })]
    });

    await apolloServer.start();

    app.use(
        cors(),
        bodyParser.json(),
        expressMiddleware(apolloServer)
    );

    const port = 4000;
    httpServer.listen( {port }, () => {
        console.log(`Server started at http://localhost:${port}`);
    });
}

bootstrap();

Here is my package.json:

{
  "name": "graphql_api",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "dev": "ts-node-dev --respawn src/index.ts",
    "prebuild": "rimraf build",
    "build": "tsc && copyfiles package.json build",
    "start": "node index.js"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@types/cors": "^2.8.13",
    "@types/graphql": "^14.5.0",
    "@types/node": "^18.11.14",
    "copyfiles": "^2.4.1",
    "rimraf": "^3.0.2",
    "ts-node-dev": "^2.0.0",
    "typescript": "^4.9.4"
  },
  "dependencies": {
    "@apollo/server": "^4.3.0",
    "body-parser": "^1.20.1",
    "class-validator": "^0.14.0",
    "cors": "^2.8.5",
    "express": "^4.18.2",
    "graphql": "^16.6.0",
    "reflect-metadata": "^0.1.13",
    "type-graphql": "^2.0.0-beta.1"
  }
}

And this is the Mutation I'm trying to call:

mutation Mutation($user: AddUserInput!) {
  addUser(user: $user) {
    id
    email
    firstName
    lastName
  }
}

Variables:

{
  "user": {
    "email": "[email protected]",
    "firstName": "John",
    "lastName": "Smith"
  }
}

The error response I get:

{
    "errors": [
        {
            "message": "Argument Validation Error",
            "locations": [
                {
                    "line": 1,
                    "column": 43
                }
            ],
            "path": [
                "addUser"
            ],
            "extensions": {
                "code": "INTERNAL_SERVER_ERROR",
                "stacktrace": [
                    "Error: Argument Validation Error",
                    "    at validateArg (D:\\Temp\\TypeGraphQL_Issue\\node_modules\\type-graphql\\dist\\resolvers\\validate-arg.js:55:15)",
                    "    at processTicksAndRejections (internal/process/task_queues.js:93:5)",
                    "    at async Promise.all (index 0)"
                ]
            }
        }
    ],
    "data": null
}

Environment (please complete the following information):

• OS: Windows 10
• Node v14.15.3
• Package version 2.0.0-beta.1
• TypeScript version 4.9.4
• Apollo server version: 4.3.0

Describe the Bug Error after subscription client.

To Reproduce

/// server
import { ApolloServer } from 'apollo-server-express';
import express from 'express';
import { useServer } from 'graphql-ws/lib/use/ws';
import { createServer } from 'http';
import { WebSocketServer } from 'ws';
/// ...

  const app = express();
  const httpServer = createServer(app);
  const wsServer = new WebSocketServer({
    server: httpServer,
    path: '/',
  })

  const schema = buildFederatedSchema({ orphanedTypes, resolvers, pubSub })
  const serverCleanup = useServer({ schema }, wsServer);
  const server = new ApolloServer({ schema });
  
  await server.start();
  server.applyMiddleware({ app, path: '/' });
  httpServer.listen({ port }, ... );


/// resolver
import { withFilter } from 'graphql-subscriptions';
import {
  Resolver,
  Root,
  Args,
  Subscription,
} from 'type-graphql';
/// ...

@Resolver()
export class SubscriptionResolver {
  @Subscription(() => Notification, {
    subscribe: withFilter(
      () => pubSub.asyncIterator(topics),
      (root, args) => {
        return args.type === root.type;
      },
    ),

    // subscribe() {
    //   return pubSub.asyncIterator(topics);
    // },

    // topics,
    // topics: ({ args }) => args.type,
    
    // filter: ({ args, payload }) => {
    //   return args.type === payload.type;
    // },
  })
  notifications(@Root() payload: NotificationPayload, @Args() args: NotificationArgs) {
    return {
      type: args.typeNotify,
      date: payload.date,
      meta: payload?.meta,
    };
  }

Expected Behavior After execution of subscription operation on Studio ApolloGraphql sandbox, i expect to connect to the socket, and receive messages on the emission of events. But get the error subscribe

Logs

...
🚀 Query endpoint ready at http://localhost:3008/
🚀 Subscriptions ready at ws://localhost:3008/
Internal error occurred during message handling. Please check your implementation. Error: Subscription field must return Async Iterable. Received: undefined.
    at createSourceEventStream (/***/node_modules/graphql/execution/subscribe.js:165:13)
    at processTicksAndRejections (node:internal/process/task_queues:96:5)
    at async subscribe (/***/node_modules/graphql/execution/subscribe.js:67:26)
    at async onMessage (/***/node_modules/graphql-ws/lib/server.js:191:51)
    at async WebSocket.<anonymous> (/***/node_modules/graphql-ws/lib/use/ws.js:83:21)

Environment (please complete the following information):

• Package version - v1.2.0-rc.1
• OS: MacOS Monteray
• Node - 16.17.0
• TypeScript version - 4.7.4
• npm - v1.2.0-rc.1

Additional Context Add any other context about the problem here.

Describe the Bug The conversion function assumes that new Date("some garbage") will throw an exception for bad input values on the Date constructor. When given bad inputs the Date object will just return Invalid Date which is still a Date object, and not throw.

To Reproduce Create an input object with a field which is type Date Pass in in invalid date string for that fields value The field get set to null

Expected Behavior Throws the error here https://github.com/MichalLytek/type-graphql/blob/3137ab532fbe6742d06f938d95eefddee1eea435/src/scalars/isodate.ts#L7 back to the caller.

Environment (please complete the following information):

• OS: Linux
• Node 16.17
• Package version 1.2.0-rc1
• TypeScript version 4.7

Additional Context I've replaced the provided GraphQLISODateTime with my own copy of it and have modified the conversion function like so to fix this for us.

function convertStringToDate(dateString: string) {
  const value = new Date(dateString);
  if (value instanceof Date && !isNaN(value.valueOf())) {
    return value;
  }
  throw new Error("Provided date string is invalid and cannot be parsed");
}