graphql.js

const { GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLList, GraphQLSchema, GraphQLBoolean, GraphQLNonNull } = require('graphql');

const UserType = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: { type: GraphQLInt },
    username: { type: GraphQLString },
    email: { type: GraphQLString },
    created_at: { type: GraphQLString },
    articles: {
      type: new GraphQLList(ArticleType),
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          db.query('SELECT * FROM articles WHERE author_id = ?', [parent.id], (err, results) => {
            if (err) reject(err);
            else resolve(results);
          });
        });
      }
    }
  })
});

const ArticleType = new GraphQLObjectType({
  name: 'Article',
  fields: () => ({
    id: { type: GraphQLInt },
    title: { type: GraphQLString },
    content: { type: GraphQLString },
    summary: { type: GraphQLString },
    author_id: { type: GraphQLInt },
    category: { type: GraphQLString },
    tags: { type: GraphQLString },
    is_published: { type: GraphQLBoolean },
    created_at: { type: GraphQLString },
    author: {
      type: UserType,
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          db.query('SELECT * FROM users WHERE id = ?', [parent.author_id], (err, results) => {
            if (err) reject(err);
            else resolve(results[0]);
          });
        });
      }
    }
  })
});

const RootQuery = new GraphQLObjectType({
  name: 'RootQueryType',
  fields: {
    user: {
      type: UserType,
      args: { id: { type: GraphQLInt } },
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          db.query('SELECT * FROM users WHERE id = ?', [args.id], (err, results) => {
            if (err) reject(err);
            else resolve(results[0]);
          });
        });
      }
    },
    users: {
      type: new GraphQLList(UserType),
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          db.query('SELECT * FROM users', (err, results) => {
            if (err) reject(err);
            else resolve(results);
          });
        });
      }
    },
    article: {
      type: ArticleType,
      args: { id: { type: GraphQLInt } },
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          db.query('SELECT * FROM articles WHERE id = ?', [args.id], (err, results) => {
            if (err) reject(err);
            else resolve(results[0]);
          });
        });
      }
    },
    articles: {
      type: new GraphQLList(ArticleType),
      args: {
        category: { type: GraphQLString },
        search: { type: GraphQLString }
      },
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          let query = 'SELECT * FROM articles WHERE is_published = TRUE';
          const params = [];
          
          if (args.category) {
            query += ' AND category = ?';
            params.push(args.category);
          }
          
          if (args.search) {
            query += ' AND (title LIKE ? OR content LIKE ? OR tags LIKE ?)';
            const searchTerm = `%${args.search}%`;
            params.push(searchTerm, searchTerm, searchTerm);
          }
          
          query += ' ORDER BY created_at DESC';
          
          db.query(query, params, (err, results) => {
            if (err) reject(err);
            else resolve(results);
          });
        });
      }
    }
  }
});

const RootMutation = new GraphQLObjectType({
  name: 'Mutation',
  fields: {
    createArticle: {
      type: ArticleType,
      args: {
        title: { type: new GraphQLNonNull(GraphQLString) },
        content: { type: new GraphQLNonNull(GraphQLString) },
        summary: { type: GraphQLString },
        category: { type: GraphQLString },
        tags: { type: GraphQLString },
        author_id: { type: new GraphQLNonNull(GraphQLInt) },
        is_published: { type: GraphQLBoolean }
      },
      resolve(parent, args, { db }) {
        return new Promise((resolve, reject) => {
          const { title, content, summary, category, tags, author_id, is_published } = args;
          db.query(
            'INSERT INTO articles (title, content, summary, category, tags, author_id, is_published) VALUES (?, ?, ?, ?, ?, ?, ?)',
            [title, content, summary || '', category || 'general', tags || '', author_id, is_published || false],
            (err, result) => {
              if (err) reject(err);
              else {
                db.query('SELECT * FROM articles WHERE id = ?', [result.insertId], (err, results) => {
                  if (err) reject(err);
                  else resolve(results[0]);
                });
              }
            }
          );
        });
      }
    }
  }
});

module.exports = new GraphQLSchema({
  query: RootQuery,
  mutation: RootMutation
});