Prisma

have you been through this tutorial?  <https://www.graph.cool/docs/tutorials/react-apollo-auth0-pheiph4ooj/>

But my scenario is not the same as the one here 

I want my customers to sign up with their social accounts later in my flow for accessing features 

use exclusively auth0, which by defaults lets users signup using an email and password of their choosing

Using the auth0 modal displayed after calling lock.show() 

or to use <http://prntscr.com/fvc5i2> and then use auth0 later on to allow them to attach their social accounts

Cleaner than what I was thinking to do at first :D

no problem.  glad I could help :slightly_smiling_face:

"WebSocket is closed before the connection is established." anybody else constantly have issues with their websocket connection?

<@U67GHF6V6> I think they are aware of the issue <https://graphcool.slack.com/archives/C0MQJ62NL/p1499951461672950>

Is there a way to issue a GraphQL request from a browser that just returns the JSON instead of loading the playground?

<@U68CP2F0S> can you elaborate what you mean wit that?

<@U68CP2F0S> graphql's payload and response are just json <http://prntscr.com/fvd8vh>

What I want to be able to do is go into a browser, enter something like
<https://api.graph.cool/simple/v1/[my> project key]/query=allAttractions?query=query%7BallAttractions%7Bname%7D%7D
and have it return the JSON instead of opening the playground

I think using cURL is the right thing here

```
curl '<https://api.graph.cool/simple/v1/cixos23120m0n0173veiiwrjr>' -H 'content-type: application/json' --data-binary '{"query":"query {\n  allMovies {\n    id\n  }\n}","variables":null}'
```

Nilan, curl is fine, but I was hoping we could make HTTP requests in a browser and get a JSON response.

Is there not an endpoint that responds to web requests directly?

your endpoint reacts to HTTP POST directly, and to HTTP GET with the playground

anybody run into this: Error: GraphQL error: The provided idToken is invalid. Please see <https://auth0.com/docs/tokens/id_token> for how to obtain a valid idToken
    at new ApolloError (ApolloError.js:32)
    at QueryManager.js:119
    at &lt;anonymous&gt;

you're probably using a `RS256` and not a `HS256` token

we'll soon support RS256 tokens as well so at this point it's probably not worth it to switch to `HS256` in your app :slightly_smiling_face:

<@U67GHF6V6> yes, you need do the following:

1) Open your Auth0 console
2) Clients
3) Select a client
4) At the bottom, click "Advanced settings"
5) Under Oauth, change *JsonWebToken Signature Algorithm* to HS256

<@U68CP2F0S> in chrome, open the developer tools inspector and paste this code into the console <https://gist.github.com/cj/da59049ba2f48e1cdc263f64f4e85b15> :slightly_smiling_face:

Im using the withApollo HOC when i submit a form to run some mutation, the problem is is that the data that is returned is not passed into my props, does anyone know how to access this data?

`withApollo` injects a client instance that allows you to create a promise that sends a query. `then`-ing the promise gives access to the data

if you want to have access to the data via `props`, you need to use the `graphql` HOC instead

<@U65AG2TFB> shoot me a sample of the code you're trying to get working and I'll be happy to help :slightly_smiling_face:

<@U45G4SS7L> This the handle submit of the form
```
handleSubmit: (payload, { props }) =&gt; {
    props.client
      .query({
        query: findUserQuery,
        variables: { email: payload.email }
      })
      .then(({ data }) =&gt; {
        if (data.User != null) {
          return props.client.mutate({
            mutation: createRideWithExistingUserMutation,
            variables: { userId: data.User.id, ...rideObject(payload) }
          })
        }
        return props.client.mutate({
          mutation: createUserAndRideMutation,
          variables: { email: payload.email, ...rideObject(payload) }
        })
      })
      .catch(e =&gt; console.log(e))
  }
```

problem is the data being returned is not then passed into props from the cache

<@U0RQY0KK5> Becuase Im doing some logic on deciding what mutate to run is ther a way to do this with the graphql HOC

<@U65AG2TFB> sorry, kids got home... why wouldn't you just use `graphql` as <@U0RQY0KK5> suggested and then do something like:

```
handleSubmit: async (payload, { props }) =&gt; {
  const defaultData = { ...rideObject(payload) }
  const { User } = await props.findUser({ email: payload.email })

  if (User) {
    return props.createRideWithExistingUser({ userId: User.id, ...defaultData })
  } else {
    return props.createUserAndRide({ email: payload.email, ...defaultData })
  }
}
```

I'll be back a bit later, need to get them to bed

this line looks good but I didnt think it was possible to calla query from a prop `const { User } = await props.findUser({ email: payload.email })`

<@U65AG2TFB> that's what `import { graphql } from 'react-apollo'` is for <http://dev.apollodata.com/react/higher-order-components.html>

<@U45G4SS7L> But I thought queries passed into graphql, run immediately on load and that it was only mutations that you can call inside a component through props.

Where are the docs that say I can run a query through props

<@U45G4SS7L> Did you maybe mean use the `withApollo` HOC for the query and then use `graphql` for the mutations therefore being able to access the mutation results in the props

@sambmason - if you use withApollo then you are doing the graphql query imperatively inside your component, so it would not make sense for the data to go into props (which are for things passed into your component from outside). You should use setState in the then() part of the promise returned by props.client.query (or dispatch an action if you are using redux for state) and then have your component render based on state rather than props

<@U5ZDXT94Z>  I ended up with a mix of withApollo and graphql, I set up the mutations with `graphql` so I could use them in the props with `props.mutate` and then used the withApollo to setup a `props.client.query` to fetch the the user in the submit handler and the pass that value to the mutations. It seemed to work pretty well

Soooo… in a request pipeline function, I see that data transformations are ignore. If this is the case, how can I store data from the external API on our object (<http://d.pr/i/M5Nyny.png>)

<@U5JHA40K1> Like it says in the next line, in a `TRANSFORM_ARGUMENT` hook instead of `PRE_WRITE`

Wait, can I return a promise inside a TRANSFORM_ARGUMENT then?

I thought `PRE_WRITE` is where you call the API function, but if I can do it in transform argument, it is straight-forward

You can do exactly the same in both hooks AFAIK, the only difference is that you cannot transform the data in `PRE_WRITE`.

<@U5P82S230> is right :slightly_smiling_face: 

is the best way to access the currently logged in user to always add a userQuery on each component that needs the current user?

I’m wondering the same - seems not so great to have to do that on every single component.

I think this thread is relevant: <https://graphcool.slack.com/archives/C0MQJ62NL/p1499984554889427>

Question: I have my session token stored in a cookie, how do I check if that token is valid?

<https://www.graph.cool/docs/faq/graphcool-session-user-goij0cooqu/>