@graphql-reveal/sequel

Map your graphql schema to a database like MySQL/PostgreSQL/Sqlite with sequelize. It tries to infer relationships between types, currently supporting belongsTo, hasMany and belongsToMany. It also forms the basic mutations necessary to create, update, and delete objects, as well as assoicate many-to-many relationships.

We use @model directive to let you specify how to map your schema to database models.

type Query {
  findSequelEmployees(where: SequeEmployeeFilter): [SequelEmployee]
  fetchSequelEmployees(next: ID, limit: Int): [SequelEmployee]
  sequelEmployee(id: ID): SequelEmployee
  sequelEmployees: [SequelEmployee]

  findSequelCompanies(where: SequeCompanyFilter): [SequelCompany]
  fetchSequelCompanies(next: ID, limit: Int): [SequelCompany]
  sequelCompany(id: ID): SequelCompany
  sequelCompanies: [SequelCompany]
}

type Mutation {
  createSequelEmployee(request: SequelEmployeeRequest): SequelEmployee
  updateSequelEmployee(request: SequelEmployeeRequest): SequelEmployee
  deleteSequelEmployee(request: SequelEmployeeRequest): SequelEmployee
  createSequelCompany(request: SequelCompanyRequest): SequelCompany
  updateSequelCompany(request: SequelCompanyRequest): SequelCompany
  deleteSequelCompany(request: SequelCompanyRequest): SequelCompany
}

type SequelCompany @model(name: "company") {
  id: ID! @primary
  name: String
  industry: String
  employees: [SequelEmployee] @hasMany
}

type SequelEmployee @model(name: "employee") {
  id: ID! @primary
  firstName: String
  lastName: String
  address: String @default(value: "")
  # subordinates: [SequelEmployee] @hasMany
  company: SequelCompany @belongsTo
}

input SequelCompanyRequest {
  id: ID
  name: String!
  industry: String
}

input SequelEmployeeRequest {
  id: ID
  firstName: String!
  lastName: String!
  address: String
  companyId: ID
}

input SequeCompanyFilter {
  id: ID
  ids: [ID]
  name: String
}

input SequeEmployeeFilter {
  id: ID
  ids: [ID]
  firstName: String
  lastName: String
}

To use it in GraphQL Modules, import SequelDirectiveModule and buildSequelResolvers from @graphql-reveal/sequel and mock the modules for rapid prototyping.

import 'graphql-import-node';
import { GraphQLModule } from '@graphql-modules/core';
import { SequelDirectiveModule, buildSequelResolvers } from '@graphql-reveal/sequel';
import { Sequelize } from 'sequelize';
import * as typeDefs from './type.graphql';
import { seedData } from './seed';

const sequelize = new Sequelize('sqlite::memory:')

function buildCompositionResolver(caseStyle = 'camel') {
  const resolvers = buildSequelResolvers({ typeDefs, sequelize, caseStyle });
  sequelize.sync().then(() => {
    const queryInterface = sequelize.getQueryInterface();
    for (const key of Object.keys(seedData)) {
      queryInterface.bulkInsert(key, seedData[key]);
    }
  });
  return resolvers;
}

export const SequelExampleModule = new GraphQLModule({
  name: 'SequelExample',
  imports: [
    SequelDirectiveModule.forRoot({ sequelize })
  ],
  typeDefs,
  resolvers: buildCompositionResolver()
});