Cannot read property 'sqlTable' of undefined

Join-monster fails with

(node:3555) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 11): TypeError: Cannot read property 'sqlTable' of undefined

OR

{
	"errors": [
		{
			"message": "Cannot read property 'sqlTable' of undefined",
			"locations": [
				{
					"line": 2,
					"column": 2
				}
			],
			"path": [
				"orders"
			]
		}
	],
	"data": {
		"orders": null
	}
}

Here is my code

const Order =  new graphql.GraphQLObjectType({
    name    : "Order",
    sqlTable: `order`,
    uniqueKey: "id",
    fields  : () => ({
        order_id    : {
            type: graphql.GraphQLString,
        },
    }),
});

module.exports = new graphql.GraphQLSchema({
    query : new graphql.GraphQLObjectType({
        name    : "Query",
        fields  : () => ({
            orders: {
                type    : Order,
                resolve :(obj, args, context, resolveInfo) => {
                    return join_monster(resolveInfo, context, sql => {
                        return pg.query(sql);
                    });
                },
            },
        }),
    }),
});

[naturalethic]

@zhorzhz Can you please re-open this.

I looked into the graphql code for the new version and they no longer expose type._typeConfig after the type is constructed. Here’s a temporary work-around until the join-monster developers can deal with this in a better way.

Originally your code would have looked something like this:

const User = new gql.GraphQLObjectType({
  name: 'User',
  sqlTable: 'user',
  uniqueKey: 'id'
  fields: () => ({
    id: {
      type: gql.GraphQLInt
    }
  })
})

The fix is to now only define the graphql specific properties in the type constructor, then provide the join-monster properties afterward like so:

const User = new gql.GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: gql.GraphQLInt
    }
  })
})

User._typeConfig = {
  sqlTable: 'user',
  uniqueKey: 'id'
}

[wtho]

@s97712 yeah, that is why I used the original object.

Another way how your solution should work would be to name the class the same (untested):

import { GraphQLObjectType as OriginalGraphQLObjectType } from 'graphql';
export class GraphQLObjectType extends OriginalGraphQLObjectType {
  // ...
}

I personally prefer duck typing over constructor name comparison, but it is clearly more efficient to just check the constructor name. Maybe the maintainers are open for a PR to change this (for more extensibility). Let us know in case you read this :bowtie: