const { makeExecutableSchema } = require('graphql-tools');
const { fileLoader, mergeResolvers, mergeTypes } = require('merge-graphql-schemas');
const path = require('path');

const resolversArray = fileLoader(
  path.join(__dirname, './resolvers/'),
  { recursive: true, extensions: ['.js'] },
);
const typesArray = fileLoader(
  path.join(__dirname, './types/'),
  { recursive: true, extensions: ['.gql'] },
);
const resolvers = mergeResolvers(resolversArray);
const typeDefs = mergeTypes(typesArray, { all: true });
module.exports = makeExecutableSchema({ typeDefs, resolvers });


------------------------------------------------------------------------------


const bcrypt = require('bcrypt');
const jsonwebtoken = require('jsonwebtoken');
const {
  User,
} = require('./../../models');
require('dotenv').config();

module.exports = {
  Mutation: {
    async signup(_, { input }) {
      const user = await User.create({
        username: input.username,
        email: input.email,
        password: await bcrypt.hash(input.password, 10),
      });

      return jsonwebtoken.sign({
        id: user.id,
        email: user.email,
      },
      process.env.JWT_SECRET, {
        expiresIn: '1y',
      });
    },

    async login(_, { input }) {
      const user = await User.findOne({
        email: input.email,
      });

      if (!user) {
        throw new Error('No user with that email');
      }

      const valid = await bcrypt.compare(input.password, user.password);

      if (!valid) {
        throw new Error('Incorrect password');
      }

      const token = jsonwebtoken.sign({
        id: user.id,
        email: user.email,
      },
      process.env.JWT_SECRET, {
        expiresIn: '1d',
      });

      return { token, role: user.role };
    },
  },
};




-------------------------------------------------------------


type Login {
  token: String!
  role: String!
}

input LoginInput {
  email: String!
  password: String!
}

input SignupInput {
  email: String!
  password: String!
  username: String!
  invited: Boolean
}

type Mutation {
  login (input: LoginInput): Login
  signup (input: SignupInput): String
}

type Query {
  _empty: String
}


-----------------



const { PubSub } = require('graphql-subscriptions');

const { Course } = require('./../../models');

const COURSES_ADDED = 'courses_added';
const COURSES_UPDATED = 'courses_update';
const COURSES_DELETED = 'courses_deleted';

const pubsub = new PubSub();

module.exports = {
  Query: {
    async courses(_, args, { user }) {
      const courses = await Course.find();
      return courses;
    },

    async course(_, { id }) {
      const course = await Course.findById(id);
      return course;
    },
  },

  Mutation: {
    async storeCourse(_, { input }, { user }) {
      const courseData = { ...input };
      courseData.owner = user.id;
      const course = await Course.create(courseData);
      pubsub.publish(COURSES_ADDED, { courseAdded: course });
      return course;
    },

    async updateCourse(_, { input }) {
      const courseData = { ...input };
      const course = await Course.findByIdAndUpdate(
        courseData.id,
        courseData,
        { new: true },
      );
      pubsub.publish(COURSES_UPDATED, { courseUpdated: course });
      return course;
    },

    async deleteCourse(_, { id }) {
      await Course.findById(id).remove().exec();
      pubsub.publish(COURSES_DELETED, { deaprtmentDeleted: id });
      return id;
    },
  },

  Subscription: {
    courseAdded: {
      subscribe: () => pubsub.asyncIterator(COURSES_ADDED),
    },
    courseUpdated: {
      subscribe: () => pubsub.asyncIterator(COURSES_UPDATED),
    },
    courseDeleted: {
      subscribe: () => pubsub.asyncIterator(COURSES_DELETED),
    },
  },
};