export default function Schema(db){

const userType = new GraphQLObjectType({
    name:'User',
    description:'Single user in system',
    fields:()=>({
        user_id:{type:new GraphQLNonNull(GraphQLInt)},
        name:{type:GraphQLString},
        friends:{
            type:userConnection.connectionType,
            args:connectionArgs,
            resolve:(obj,args)=>connectionFromPromisedArray(db.collection('user').find({user_id:{$in:obj.friends[0]}}).toArray(),args)
            }
    })
})

const userConnection = connectionDefinitions({name:'User',nodeType:userType})

const viewerType = new GraphQLObjectType({
    name:'Viewer',
    description:'Currently logged in user on App',
    fields:()=>({
        id:{
            type:GraphQLString,
            resolve:(obj)=>{
                //console.log(obj)
            return obj.id
            }
            },
        user:{
            type:userType,
            args:{
                user_id:{type:new GraphQLNonNull(GraphQLInt)}
            },
            resolve:(obj,args)=>{
                console.log(args)
                return db.collection('user').findOne({user_id:args.user_id})
        }
    }
})
})

const Query = new GraphQLObjectType({
    name:'Query',
    fields:()=>({
        viewer:{type:viewerType,resolve:()=>({id:'initialId'})}
    })
})

const authenticateMutation = mutationWithClientMutationId({
    name:'authenticateMutation',

    inputFields:{
        name:{type:GraphQLString},
        password:{type:GraphQLString}
    },

    outputFields:{
        viewer:{
            type:viewerType,
            resolve:(data)=>{

            console.log('-----outputFields-------')
            console.log({id:data.user_id})
            return {id:data.user_id}
                            }
        }
   },
    mutateAndGetPayload:({name,password})=>{
        return db.collection('user')
        .findOne({name:name,password:password})
        .then(data=>data)
        }
})

const Mutation = new GraphQLObjectType({
    name:'Mutations',
    fields:()=>({
        authenticateMutation:authenticateMutation
    })
})

const schema =  new GraphQLSchema({
    query:Query,
    mutation:Mutation
})
return schema
}

import React from 'react';
import Relay from 'react-relay';
import ReactDOM from 'react-dom';
import { browserHistory, applyRouterMiddleware, Router } from 'react-router';
import useRelay from 'react-router-relay';
import Route from './routes/Route';


ReactDOM.render(
  <Router
    history={browserHistory}
    routes={Route}
    render={applyRouterMiddleware(useRelay)}
    environment={Relay.Store} />,
  document.getElementById('content')
);

import React from 'react';
import Relay from 'react-relay';

class AppContainer extends React.Component{
    componentDidMount(){
        console.log('-----Container-----')
        console.log(this.props)
    }

    render(){
        return <div>{React.Children.map(this.props.children,child=>{
            return React.cloneElement(child,{
                viewer:this.props.viewer
            })
        })}</div>
    }
    }

export default Relay.createContainer(AppContainer,{
    fragments:{
        viewer:()=>Relay.QL`fragment on Viewer{
            id
        }`
    }
})

import React from 'react';
import Relay from 'react-relay';
import authenticateMutation from '../mutations/authenticateMutation'

var onSuccess = ()=>{
    console.log('Success')
}

var onFailure = (transaction)=>{
    var error = transaction.getError()|| new Error('My error')
    console.log(error)
}

class Login extends React.Component{

    componentDidMount(){
        console.log('-----Relay Store before')
        console.log(Relay.Store)
    }

    handleLogin = (e)=>{
        console.log(this.props)
        console.log(this.state.userText)
        let onSuccess = onSuccess
    Relay.Store.commitUpdate(new authenticateMutation({
        name:this.state.userText,
        password:this.state.userPass,
        viewer:this.props.viewer
    }),{onFailure,onSuccess})
    }

    textChange = (e)=>{
        if(e.target.type==='text')
            this.state.userText = e.target.value
        else
            this.state.userPass = e.target.value

    }

    state = {
        userText:'',
        userPass:''
    }

    render(){
        return (<div>
                    <h4>Login</h4>
                        <div>
                            <input placeholder='username' onChange={this.textChange}/>
                            <input type='password' placeholder = 'password' onChange={this.textChange} />
                            <button onClick={this.handleLogin}>Login</button>
                        </div>
                </div>)
    }
}

export default Login

import Relay from 'react-relay'

export default class extends Relay.Mutation{
    getMutation(){
        return Relay.QL`mutation{authenticateMutation}`
    }
    getVariables(){
        return {
            name:this.props.name,
            password:this.props.password
        }
    }

    getFatQuery(){
        return Relay.QL`fragment on authenticateMutationPayload{
            viewer{id}
        }`
    }

    getConfigs() {
    return [{
      type: 'FIELDS_CHANGE',
      fieldIDs: {viewer:this.props.viewer.id}
    }];
  }
}

{"data":{"authenticateMutation":{"clientMutationId":"0","viewer":{"id":"1"}}}}