charlotte-graphql/lib/typedefs.js

Generates GraphQL type definitions and resolvers off of a concise spec.

'use strict';

const _ = require('lodash');
const { expandTypes, unrequire } = require('./helpers');
const findOperators = require('./find-operators');

const generateTypeDefs = ({
  types,
  typesExpanded
}) => {
  typesExpanded = typesExpanded || expandTypes(types);

  const typeDefinitions = Object.values(typesExpanded).map(type => `type ${type.name} {
    ${Object.values(type.fields).map(field => `${field.name}: ${field.typeDescriptor}`).join('\n    ')}
  }`).join('\n\n  ');

  const conditionsInputs = Object.values(typesExpanded).map(type => {
    const fields = Object.values(type.fields);
    const scalars = fields.filter(field => field.type.isScalar);

    let input = `input ${type.name}Conditions {
      ${
        fields
          .map(field => {
            return field.type.isScalar
              ? `${field.name}: [${field.type.name}!]`
              : `${field.name}: [${field.type.name}Conditions!]`;
          })
          .concat(
            scalars.length > 0
              ? findOperators.map(op => `${op}: ${type.name}OpArgs`)
              : []
          )
          .join('\n    ')
      }
    }`;

    if (scalars.length === 0) {
      return input;
    }

    return input + `

    input ${type.name}OpArgs {
      ${scalars.map(field => `${field.name}: ${field.type.name}`).join('\n      ')}
    }`;
  }).join('\n\n  ');

  const updateInputs = Object.values(typesExpanded).map(type => `input ${type.name}Updates {
    ${Object.values(type.fields).map(field => {
      return field.type.isScalar
        ? `${field.name}: ${field.type.name}`
        : `${field.name}: IdentityInput`;
    }).join('\n    ')}
  }`).join('\n\n  ');

  const standardInputs = `input IdentityInput {
    uuid: ID!
  }

  input PaginationInput {
    limit: Int
    offset: Int
  }`;

  const queries = Object.values(typesExpanded).map(type => `
    ${type.nameCamel}(
      uuid: ID!
    ): ${type.name}

    ${type.pluralCamel}(
      conditions: [${type.name}Conditions!],
      pagination: PaginationInput
    ): [${type.name}!]!
  `).join('');

  const mutations = Object.values(typesExpanded).map(type => `
    create${type.name}(
      ${
        Object
          .values(type.fields)
          .filter(field => {
            return !field.reciprocalOf && ['uuid', '_created', '_updated'].indexOf(field.name) === -1;
          })
          .map(field => {
            return field.type.isScalar
              ? `${field.name}: ${field.typeDescriptor}`
              : `${field.name}: ${field.appendRequirement('IdentityInput')}`;
          })
          .join(',\n      ')
      }
    ): ${type.name}!

    update${type.name}(
      uuid: ID!,
      updates: ${type.name}Updates!
    ): ${type.name}

    update${type.plural}(
      conditions: [${type.name}Conditions!]!,
      updates: ${type.name}Updates!
    ): [${type.name}!]!

    remove${type.name}(
      uuid: ID!
    ): Boolean!
  `).join('');

  return `
  ${typeDefinitions}

  ${conditionsInputs}

  ${updateInputs}

  ${standardInputs}

  type Query {${queries}}

  type Mutation {${mutations}}`;
};

module.exports = {
  generateTypeDefs
};