import 'reflect-metadata';
import Fastify from 'fastify';
import mercurius from 'mercurius';
import { registerDb } from './db';
import { User } from './entity/User';
import { Post } from './entity/Post';

const fastify = Fastify( {
    logger: true
});


const schema = `
    type User {
        id: ID!
        name: String!
        posts: [Post!]!
    }

    type Post {
        id: ID!
        title: String!
        author: User!
    }

    type Query {
        user(id: ID!): User
    }

    type Mutation {
        createUser(name: String!): User
        createPost(title: String!, userId: ID!): Post
    }
`
const resolvers = {
    Query: {
        user: async (_: unknown, { id }: {id: number} ) => {
            const userRepository = fastify.orm.getRepository(User)
            return await userRepository.findOne({where: { id}, relations: ['posts']})
        }
    },
    Mutation: {
        createUser: async (_: unknown, { name }: {name: string}) => {
          const user = new User();
          user.name = name;
          
          const userRepository = fastify.orm.getRepository(User)
          await userRepository.save(user);
          return user;
        },
        createPost: async (_: unknown, { title, userId }: {title: string, userId: number}) => {
          const userRepository = fastify.orm.getRepository(User)
          const user = await userRepository.findOne({ where: { id: userId } });
          if (!user) {
            throw new Error("User not found");
          }
    
          const postRepository = fastify.orm.getRepository(Post)
          const post = new Post();
          post.title = title;
          post.author = user;
          await postRepository.save(post);
          return post;
        }
      }
}

registerDb(fastify);

fastify.register(mercurius, {
    schema,
    resolvers,
    graphiql: true
})

fastify.listen({ port: 3000}, function (err, address) {
    if (err) {
        fastify.log.error(err);
        process.exit(1);
    }
    console.log(`Server listening on ${address}`);
})