Having issues returning a result from a Mutation combining Sequelize.

[atresnjo]

Explanation: Basically, typescript complains about the mutations that return the "Account" model. If I remove the "orders" Field from the Account type, typescript stops complaining. What am I doing wrong? Thanks for the great work and help! :)

versions

    "@graphql-codegen/cli": "1.20.1",
    "@graphql-codegen/introspection": "1.18.1",
    "@graphql-codegen/typescript": "1.20.2",
    "@graphql-codegen/typescript-resolvers": "^1.18.1",

codegen.yml

overwrite: true
schema: ./src/schema.graphql
watch: true
generates:
    src/generated/graphql.ts:
        config:
            useIndexSignature: true
        plugins:
            - 'typescript'
            - 'typescript-resolvers'
    ./graphql.schema.json:
        plugins:
            - 'introspection'

generated code

export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = ResolversObject<{
  login?: Resolver<Maybe<ResolversTypes['Account']>, ParentType, ContextType, RequireFields<MutationLoginArgs, 'email' | 'password'>>;
}>;

export type MutationLoginArgs = {
  email: Scalars['String'];
  password: Scalars['String'];
};

export type ProductResolvers<ContextType = any, ParentType extends ResolversParentTypes['Product'] = ResolversParentTypes['Product']> = ResolversObject<{
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  title?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  description?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  imageUrl?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  price?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  isTrending?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  totalRating?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  orders?: Resolver<Maybe<Array<Maybe<ResolversTypes['CheckoutOrder']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}>;

export type AccountResolvers<ContextType = any, ParentType extends ResolversParentTypes['Account'] = ResolversParentTypes['Account']> = ResolversObject<{
  email?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  password?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  token?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  orders?: Resolver<Maybe<Array<Maybe<ResolversTypes['CheckoutOrder']>>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}>;

export type CheckoutOrderResolvers<ContextType = any, ParentType extends ResolversParentTypes['CheckoutOrder'] = ResolversParentTypes['CheckoutOrder']> = ResolversObject<{
  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
  products?: Resolver<Maybe<Array<Maybe<ResolversTypes['Product']>>>, ParentType, ContextType>;
  user?: Resolver<ResolversTypes['Account'], ParentType, ContextType>;
  price?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  purchasedAt?: Resolver<Maybe<ResolversTypes['Date']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}>;

Error

Full error log

(property) login?: ResolverFn<Maybe<ResolverTypeWrapper<Account>>, {}, any, RequireFields<MutationLoginArgs, "email" | "password">> | LegacyStitchingResolver<...> | NewStitchingResolver<...> | undefined
Type '(_: {}, args: RequireFields<MutationLoginArgs, "email" | "password">) => Promise<Account>' is not assignable to type 'ResolverFn<Maybe<ResolverTypeWrapper<Account>>, {}, any, RequireFields<MutationLoginArgs, "email" | "password">> | LegacyStitchingResolver<...> | NewStitchingResolver<...> | undefined'.
  Type '(_: {}, args: RequireFields<MutationLoginArgs, "email" | "password">) => Promise<Account>' is not assignable to type 'ResolverFn<Maybe<ResolverTypeWrapper<Account>>, {}, any, RequireFields<MutationLoginArgs, "email" | "password">>'.
    Type 'Promise<Account>' is not assignable to type 'Account | Promise<Account> | Promise<Maybe<ResolverTypeWrapper<Account>>> | null'.
      Type 'Promise<import("c:/Users/backo/Desktop/personal/foody.backend.nodejs/src/models/Account").default>' is not assignable to type 'Promise<import("c:/Users/backo/Desktop/personal/foody.backend.nodejs/src/generated/graphql").Account>'.
        Type 'import("c:/Users/backo/Desktop/personal/foody.backend.nodejs/src/models/Account").default' is not assignable to type 'import("c:/Users/backo/Desktop/personal/foody.backend.nodejs/src/generated/graphql").Account'.
          Types of property 'orders' are incompatible.
            Type 'CheckoutOrder[] | undefined' is not assignable to type 'Maybe<CheckoutOrder>[] | null | undefined'.
              Type 'CheckoutOrder[]' is not assignable to type 'Maybe<CheckoutOrder>[]'.
                Type 'CheckoutOrder' is not assignable to type 'Maybe<CheckoutOrder>'.
                  Types of property 'products' are incompatible.
                    Type 'Product[]' is not assignable to type 'Maybe<Product>[]'.
                      Property 'totalRating' is missing in type 'import("c:/Users/backo/Desktop/personal/foody.backend.nodejs/src/models/Product").default' but required in type 'import("c:/Users/backo/Desktop/personal/foody.backend.nodejs/src/generated/graphql").Product'.ts(2322)
graphql.ts(45, 3): 'totalRating' is declared here.
graphql.ts(309, 3): The expected type comes from property 'login' which is declared here on type 'WithIndex<{ createAccount?: ResolverFn<Maybe<ResolverTypeWrapper<Account>>, {}, any, RequireFields<MutationCreateAccountArgs, "email" | "password">> | LegacyStitchingResolver<...> | NewStitchingResolver<...> | undefined; createCheckoutOrder?: ResolverFn<...> | ... 2 more ... | undefined; createReview?: ResolverFn<.....'

Mutation login code

        login: async (_, args) => {
            var account = await Account.findOne({
                where: { email: args.email },
            })

            if (account === null)
                throw new UserInputError('Account does not exist')

            var token = jwt.sign(
                { 'http://localhost:8080/graphql': {} },
                jwtIdentifier,
                {
                    algorithm: 'HS256',
                    subject: args.email,
                    expiresIn: '1d',
                }
            )

            account.token = token
            return account
        },

Product Model

@Table
export default class Product extends Model {
    @Column
    title!: string

    @Column
    description!: string

    @Column
    rating!: number

    @Column
    isTrending!: boolean

    @Column
    price!: number

    @Column
    imageUrl!: string

    @BelongsToMany(() => CheckoutOrder, () => ProductCheckoutOrderJoin)
    orders: CheckoutOrder[] | undefined
}

Account Model

@Table
export default class Account extends Model {
    @Column
    email!: string

    @Column
    password!: string

    @HasMany(() => CheckoutOrder)
    orders: CheckoutOrder[] | undefined

    token!: string
}

CheckoutOrder Model

@Table
export default class CheckoutOrder extends Model {
    @Column
    price!: number

    @ForeignKey(() => Account)
    @Column
    userId!: number

    @BelongsTo(() => Account)
    user!: Account

    @BelongsToMany(() => Product, () => ProductCheckoutOrderJoin)
    products!: Product[]

    @CreatedAt
    @Column({ field: 'purchasedAt' })
    purchasedAt!: Date;
}

Join table model between Product and CheckoutOrder

import { Table, Model, Column, ForeignKey } from 'sequelize-typescript';
import CheckoutOrder from './CheckoutOrder';
import Product from './Product';

@Table
export default class ProductCheckoutOrderJoin extends Model {
    
    @ForeignKey(() => Product)
    @Column
    productId!: number;
  
    @ForeignKey(() => CheckoutOrder)
    @Column
    checkoutOrderId!: number;
}

schema

type Mutation {
    login(email: String!, password: String!): Account
}

type Account {
    email: String!
    password: String!
    token: String!
    orders: [CheckoutOrder]
}

type CheckoutOrder {
    id: ID!
    products: [Product]!
    user: Account!
    price: Int!
    purchasedAt: Date
}

type Product {
    id: ID!
    title: String!
    description: String!
    imageUrl: String!
    price: Int!
    isTrending: Boolean!
    totalRating: Int!
    orders: [CheckoutOrder]
}

[ardatan]

You should use mappers for your custom model types in resolvers.
https://graphql-code-generator.com/docs/plugins/typescript-resolvers#use-your-model-types-mappers