@bodheesh/create-bodhi-node-app/src/generators/graphql.js

Create a production-ready Node.js REST API with zero configuration

const fs = require('fs').promises;
const path = require('path');

async function generateGraphQLAPI(schema, outputDir) {
  // Generate type definitions
  const typeDefsContent = generateTypeDefinitions(schema);
  await fs.writeFile(
    path.join(outputDir, `${schema.name}.typedefs.js`),
    typeDefsContent
  );

  // Generate resolvers
  const resolversContent = generateResolvers(schema);
  await fs.writeFile(
    path.join(outputDir, `${schema.name}.resolvers.js`),
    resolversContent
  );

  // Generate input types
  const inputTypesContent = generateInputTypes(schema);
  await fs.writeFile(
    path.join(outputDir, `${schema.name}.inputs.js`),
    inputTypesContent
  );
}

function mapToGraphQLType(type) {
  const typeMap = {
    'String': 'String',
    'Number': 'Float',
    'Integer': 'Int',
    'Boolean': 'Boolean',
    'Date': 'DateTime',
    'Object': 'JSON',
    'Array': '[String]',
  };
  return typeMap[type] || 'String';
}

function generateTypeDefinitions(schema) {
  const fields = Object.entries(schema.fields)
    .map(([fieldName, field]) => {
      const type = mapToGraphQLType(field.type);
      return `    ${fieldName}: ${type}${field.required ? '!' : ''}`;
    })
    .join('\n');

  return `
const { gql } = require('apollo-server-express');

module.exports = gql\`
  scalar DateTime
  scalar JSON

  type ${schema.name} {
    id: ID!
${fields}
    createdAt: DateTime!
    updatedAt: DateTime!
  }

  type ${schema.name}Connection {
    items: [${schema.name}!]!
    totalPages: Int!
    currentPage: Int!
    totalItems: Int!
  }

  extend type Query {
    ${schema.name.toLowerCase()}s(page: Int, limit: Int, orderBy: String): ${schema.name}Connection!
    ${schema.name.toLowerCase()}(id: ID!): ${schema.name}
  }

  extend type Mutation {
    create${schema.name}(input: Create${schema.name}Input!): ${schema.name}!
    update${schema.name}(id: ID!, input: Update${schema.name}Input!): ${schema.name}!
    delete${schema.name}(id: ID!): Boolean!
  }
\`;
`;
}

function generateInputTypes(schema) {
  const createFields = Object.entries(schema.fields)
    .map(([fieldName, field]) => {
      const type = mapToGraphQLType(field.type);
      return `    ${fieldName}: ${type}${field.required ? '!' : ''}`;
    })
    .join('\n');

  const updateFields = Object.entries(schema.fields)
    .map(([fieldName, field]) => {
      const type = mapToGraphQLType(field.type);
      return `    ${fieldName}: ${type}`;
    })
    .join('\n');

  return `
const { gql } = require('apollo-server-express');

module.exports = gql\`
  input Create${schema.name}Input {
${createFields}
  }

  input Update${schema.name}Input {
${updateFields}
  }
\`;
`;
}

function generateResolvers(schema) {
  return `
const ${schema.name} = require('./${schema.name}.model');

module.exports = {
  Query: {
    ${schema.name.toLowerCase()}s: async (_, { page = 1, limit = 10, orderBy = 'createdAt' }) => {
      return await ${schema.name}.findAll({ page, limit, orderBy });
    },
    ${schema.name.toLowerCase()}: async (_, { id }) => {
      return await ${schema.name}.findById(id);
    },
  },

  Mutation: {
    create${schema.name}: async (_, { input }) => {
      return await ${schema.name}.create(input);
    },
    update${schema.name}: async (_, { id, input }) => {
      const updated = await ${schema.name}.update(id, input);
      if (!updated) {
        throw new Error('Item not found');
      }
      return updated;
    },
    delete${schema.name}: async (_, { id }) => {
      return await ${schema.name}.delete(id);
    },
  },

  ${schema.name}: {
    // Add any field resolvers here if needed
    createdAt: (parent) => new Date(parent.createdAt),
    updatedAt: (parent) => new Date(parent.updatedAt),
  },
};
`;
}

module.exports = {
  generateGraphQLAPI
};