elysiajs / elysia-graphql-yoga Goto Github PK

import { Elysia } from 'elysia'
import { yoga } from '@elysiajs/graphql-yoga'

import { createYoga, createSchema } from 'graphql-yoga'

const app = new Elysia()
    .use(
        yoga({
           // yoga property doesn't exist
            yoga: createYoga({
                schema: createSchema({
                    typeDefs: `
                        type Query {
                            hi: String
                        }
                `,
                resolvers: {
                    Query: {
                        hi: () => 'Hi from Elysia'
                    }
                }
            })
        })
    )
    .listen(8080)

  app.use(yoga({ schema }));

Context extends
	| undefined
	| MaybePromise<Record<string, unknown>>
	| ((initialContext: YogaInitialContext) => MaybePromise<unknown>),

import { context } from "./myCustomContext";

elysia
    .use(
        yoga({ schema, context }),
    )
    .listen(port);

@Resolver()
export class UserResolver {
  constructor(private userService: UserService) {}

  @Query(() => [UserModelGQL])
  async getUsers(): Promise<UserModelGQL[]> {
    return await this.userService.getAll();
  }
}

// schema.ts

export const typeDefs = `
    type Query {
        authors: [Author!]!
        author(id: ID, name: String): Author!
        books(page: Int, perPage: Int): [Book!]!
        book(name: String!): Book
    }

    type Mutation {
        addBook(name: String!, author: ID!): Book!
    }

    type Author {
        id: ID!
        name: String!
        books: [Book!]!
    }
    
    type Book {
        id: ID!
        name: String!
        author: Author!
    }

// error

Property 'Subscription' is missing in type '{ Query: { authors: () => Promise<Record[]>; author: (_parent: unknown, args: {    id?: string;    name?: string;} | undefined) => Promise<Record>; books: (_parent: unknown, args: {    page?: number;    perPage?: number;} | undefined) => Promise<Record[]>; book: (_parent: unknown, { name }: { ...; }) => Promise<...>...' but required in type '{ Query: { authors: (parent: unknown, args: {} | null | undefined, context: { request: Request; } | { [x: string]: unknown; request: Request; } | { request: Request; }, info: unknown) => MaybePromise<...>; author: (parent: unknown, args: { ...; } | undefined, context: { ...; } | ... 1 more ... | { ...; }, info: unkn...'.

const app = new Elysia()
  .use(
    yoga({
      typeDefs: /* GraphQL */`
        type User {
          id: ID!
          name: String!
          email: String!
          banned: Boolean!
        }
        
        type Query {
          user(id: ID): [User]
          createUser(name: String!, email: String!): User
          banUser(id: ID!): User
        }
      `,
      resolvers: {
        Query: {
          user: (_, args) => {
            if (args?.id) {
              const query = db.query("SELECT * FROM users WHERE id = $id")
              const result = query.all({ $id: args.id })
              return result as User[]
            } else {
              const query = db.query("SELECT * FROM users")
              const result = query.all()
              return result as User[]
            }
          },
          createUser: (_, args) => {
            const id = Math.random().toString(36).substring(7)
            const user = { id, name: args.name, email: args.email, banned: false }
            const query = db.prepare("INSERT INTO users (id, name, email, banned) VALUES ($id, $name, $email, $banned)")
            query.run({
              $id: user.id,
              $name: user.name,
              $email: user.email,
              $banned: user.banned
            })
            return user
          },
          banUser: (_, args) => {
            const user = db.query("SELECT * FROM users WHERE id = $id").get({ $id: args.id }) as User | undefined
            if (!user) return null

            const query = db.prepare("UPDATE users SET banned = $banned WHERE id = $id")
            if (user.banned) query.run({ $id: args.id, $banned: false })
            else query.run({ $id: args.id, $banned: true })

            return {
              ...user,
              banned: !user.banned
            }
          }
        }
      }
    })
  )

The last overload gave the following error:
│ Argument of type '(app: Elysia) => Elysia<"", { request: {}; store: {}; schema: {}; error: {}; meta: Record<"defs", {}> & Record<"exposed", {}> & Record<"schema", { [x: string]: { get: { body: unknown; headers: undefined; query: undefined; params: undefined; response: { ...; }; }; } & { ...; }; }>; }>' is not assignable to parameter of type 'Promise<{ default: Elysia<any, any, any, any, any, any>; }>'.