├── .babelrc
├── .gitignore
├── .npmignore
├── .travis.yml
├── LICENSE
├── README.md
├── package.json
├── recipes
    ├── README.md
    ├── SSR.md
    ├── at-cached.md
    ├── at-live.md
    ├── cashay-schema.md
    ├── multi-part-queries.md
    ├── pagination.md
    ├── persisted-state.md
    ├── subscriber.md
    ├── subscriptions.md
    └── transports.md
├── src
    ├── Cashay.js
    ├── __tests__
    │   ├── Cashay-data.js
    │   ├── Cashay-test.js
    │   ├── clientSchema.json
    │   ├── data
    │   │   ├── authors.js
    │   │   ├── comments.js
    │   │   ├── groups.js
    │   │   └── posts.js
    │   ├── parseSortPrint.js
    │   └── schema.js
    ├── createVariableDefinitions.js
    ├── helperClasses.js
    ├── index.js
    ├── mutate
    │   ├── ActiveQueries.js
    │   ├── __tests__
    │   │   ├── createMutationFromQuery-data.js
    │   │   ├── createMutationFromQuery-tests.js
    │   │   ├── mergeMutations-data.js
    │   │   ├── mergeMutations-tests.js
    │   │   ├── namespaceMutation-data.js
    │   │   ├── namespaceMutation-tests.js
    │   │   └── removeNamespacing-tests.js
    │   ├── createBasicMutation.js
    │   ├── createMutationFromQuery.js
    │   ├── findTypeInQuery.js
    │   ├── hasMatchingVariables.js
    │   ├── isMutationResponseScalar.js
    │   ├── makeArgsFromVars.js
    │   ├── makeFriendlyStore.js
    │   ├── mergeMutations.js
    │   ├── namespaceMutation.js
    │   └── removeNamespacing.js
    ├── normalize
    │   ├── __tests__
    │   │   ├── data-pagination-back.js
    │   │   ├── data-pagination-front.js
    │   │   ├── data-pagination.js
    │   │   ├── data-union.js
    │   │   ├── data.js
    │   │   ├── denormalizeStore-tests.js
    │   │   ├── mergeStores-tests.js
    │   │   └── normalizeResponse-tests.js
    │   ├── addDeps.js
    │   ├── denormalizeHelpers.js
    │   ├── denormalizeStore.js
    │   ├── duck.js
    │   ├── getCachedFieldState.js
    │   ├── getFieldState.js
    │   ├── getSubReqAST.js
    │   ├── mergeStores.js
    │   ├── normalizeResponse.js
    │   └── separateArgs.js
    ├── query
    │   ├── __tests__
    │   │   ├── parseAndInitializeQuery-data.js
    │   │   └── parseAndInitializeQuery-tests.js
    │   ├── flushDependencies.js
    │   ├── parseAndInitializeQuery.js
    │   ├── printMinimalQuery.js
    │   └── queryHelpers.js
    ├── schema
    │   ├── __tests__
    │   │   └── cashay-loader-tests.js
    │   ├── cashay-loader.js
    │   ├── introspectionQuery.js
    │   ├── transformSchema.js
    │   ├── updateSchema.babel.js
    │   └── updateSchema.js
    ├── subscribe
    │   └── processSubscriptionDoc.js
    ├── transports
    │   ├── HTTPTransport.js
    │   ├── Transport.js
    │   └── defaultHandleErrors.js
    └── utils.js
└── yarn.lock


/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 |   "presets": ["es2015", "stage-1"]
3 | }
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | lib
 2 | *.log
 3 | node_modules
 4 | .idea
 5 | coverage
 6 | .nyc_output
 7 | actualResult.json
 8 | expectedResult.json
 9 | debug.js
10 | debug.babel.js
11 | 
12 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | .idea
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 | - '5'
4 | - '4'
5 | after_success:
6 |     - './node_modules/.bin/nyc report --reporter=text-lcov | ./node_modules/.bin/coveralls'
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Matt Krick
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cashay",
 3 |   "version": "0.23.0",
 4 |   "description": "relay for the rest of us",
 5 |   "main": "lib/index.js",
 6 |   "bin": {
 7 |     "cashay-schema": "lib/schema/updateSchema.babel.js"
 8 |   },
 9 |   "loader": "lib/schema/cashay-loader",
10 |   "scripts": {
11 |     "clean": "rimraf lib",
12 |     "lint": "xo src/index.js --esnext --space --fix",
13 |     "build": "babel -d lib/ src/",
14 |     "watch": "babel -w -d lib/ src/",
15 |     "prepublish": "npm run clean && npm run build",
16 |     "test": "nyc ava ./src/**/__tests__/**/*-tests.js",
17 |     "quicktest": "ava ./src/**/__tests__/**/*-tests.js",
18 |     "buildTestSchema": "node ./lib/schema/updateSchema.babel.js src/__tests__/schema.js src/__tests__/clientSchema.json"
19 |   },
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "git+https://github.com/mattkrick/cashay.git"
23 |   },
24 |   "keywords": [
25 |     "relay",
26 |     "client",
27 |     "cache",
28 |     "redux"
29 |   ],
30 |   "author": "Matt Krick <matt.krick@gmail.com>",
31 |   "license": "MIT",
32 |   "bugs": {
33 |     "url": "https://github.com/mattkrick/cashay/issues"
34 |   },
35 |   "homepage": "https://github.com/mattkrick/cashay#readme",
36 |   "devDependencies": {
37 |     "ava": "0.15.2",
38 |     "babel-cli": "6.9.0",
39 |     "babel-preset-es2015": "^6.9.0",
40 |     "babel-preset-stage-1": "^6.16.0",
41 |     "babel-register": "^6.9.0",
42 |     "coveralls": "^2.11.9",
43 |     "nyc": "^6.4.4",
44 |     "rimraf": "2.5.2",
45 |     "xo": "0.15.1"
46 |   },
47 |   "dependencies": {
48 |     "graphql": "0.10.5",
49 |     "isomorphic-fetch": "^2.2.1",
50 |     "minimist": "^1.2.0",
51 |     "regenerator-runtime": "^0.9.6"
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/recipes/README.md:
--------------------------------------------------------------------------------
 1 | # Recipes
 2 | 
 3 | - [@live](./at-live.md)
 4 | - [@cached](./at-cached.md)
 5 | - [Multi-part queries](./multi-part-queries.md)
 6 | - [Pagination](./pagination.md)
 7 | - [Persisted state](./persisted-state.md)
 8 | - [Schema (without webpack)](./cashay-schema.md)
 9 | - [Server-side rendering](./SSR.md)
10 | - [Subscriptions](./subscriptions.md)
11 | - [Subscriber](./subscriber.md)
12 | - [Transports](./transports.md)
13 | 


--------------------------------------------------------------------------------
/recipes/SSR.md:
--------------------------------------------------------------------------------
 1 | # Server-side rending
 2 | 
 3 | Cashay supports server-side rending out of the box.
 4 | 
 5 | First, you'll need to create a redux store:
 6 | ```
 7 | const store = createStore(reducer, {});
 8 | ```
 9 | 
10 | Second, you need to create the Cashay singleton:
11 | ```
12 | import {cashay, ServerSideTransport} from 'cashay';
13 | const cashaySchema = require('cashay!./utils/getCashaySchema.js');
14 | cashay.create({
15 |   store,
16 |   schema: cashaySchema,
17 |   transport: new ServerSideTransport(...)
18 | });
19 | ```
20 | _Note: if you use a bundler like webpack, make sure that this file is included in the bundle.
21 | You'll want the `cashay` that you `import` here
22 | to be the same `cashay` that you use in your components. (singletons are no fun like that)_
23 | 
24 | Third, you'll want to stringify your state to send it down the wire:
25 | ```
26 | const initialState = `window.__INITIAL_STATE__ = ${JSON.stringify(store.getState())}`;
27 | 
28 | // assume you use a react jsx template for SSR
29 |  <html>
30 |    <body>
31 |     ...
32 |     <script dangerouslySetInnerHTML={{__html: initialState}} />
33 |    </body>
34 |  </html>
35 | ```
36 | 
37 | Finally, when it arrives on the client, you'll want to rehydrate the state:
38 | 
39 | ```
40 | const initialState = window.__INITIAL_STATE__;
41 | store = createStore(reducer, initialState);
42 | ```
43 | 
44 | And there you have it!
45 | 


--------------------------------------------------------------------------------
/recipes/at-cached.md:
--------------------------------------------------------------------------------
 1 | # @cached
 2 | 
 3 | ```
 4 | @cached(id: String, ids: [String]!, type: TypeName | [TypeName])
 5 | ```
 6 | 
 7 | Often times we want a specific document, or subset of documents, that already exist on the client.
 8 | For example, let's say you have a query (or subscription) that gets every project for team member.
 9 | Then, in your "Project Details" component, you want _just_ a single project. 
10 | And you don't want to call the server to get it.
11 | That's what `@cached` does.
12 | 
13 | Let's start with a basic example:
14 | 
15 | ```js
16 | const string = `
17 | query {
18 |   teamMembers(teamId: $teamId) @live {
19 |     id
20 |     name
21 |   }
22 |   todoItem(teamId: $teamId) @live {
23 |     id
24 |     content
25 |     teamMemberId
26 |     teamMember @cached(type: "TeamMember") {
27 |       id
28 |       name
29 |     } 
30 |   } 
31 | }`;
32 | 
33 | const options = {
34 |   variables: {teamId},
35 |   resolveCached: {teamMember: (source) => source.teamMemberId}
36 | }
37 | 
38 | function mapStateToProps() {
39 |   return {
40 |     userQuery: cashay.query(string, options)
41 |   }
42 | }
43 | ```
44 | 
45 | Above we see a subscription that returns an array of `todoItem`, as well as all of our team members.
46 | Each `todoItem` has a `teamMemberId` stored in its table, but the subscription lacks the actual `teamMember`
47 | (since that's probably stored in the TeamMember table, and a subscription only returns a single table row).
48 | However, we know the actual team member is on the client, so how do we get to it?
49 | Well, you could imperatively write a function (`for each todoItem, for each teamMember...`).
50 | But that's clunky, you'll have to memoize to to be performant, and it isn't easy to see what you're doing!
51 |  
52 | Instead, just use `@cached`, which will look in your state and find the `TeamMember` with the `id` 
53 | matching the return value of `resolveCached`.
54 | The above case works in O(1) time, since the state divided by `Type` and is hashed on `id`.
55 | 
56 | But let's say you wanted to match all documents by a certain criteria.
57 | For example, every time a team member logs into your app, they get a new socket connection.
58 | How can you see ALL the socket connections for each team member?
59 | 
60 | ```js
61 | const meetingContainerQuery = `
62 | query{
63 |   teamMembers(teamId: $teamId) @live {
64 |     id
65 |     name
66 |     userId
67 |     presence @cached(type: "[Presence]") {
68 |       userId
69 |     }
70 |   }
71 | }`;
72 | 
73 | const options = {
74 |   resolveCached: {presence: (source) => (doc) => doc.userId === source.userId}
75 | }
76 | ```
77 | 
78 | The first thing to note is the directive: `@cached(type: "[Presence]")`.
79 | `Presence` is wrapped in brackets, denoting that you want to return an array.
80 | 
81 | The second thing to note is the `resolveCached` return value.
82 | You're returning a function that returns `true` if you want to include it.
83 | This works in O(n) time, which is great. 
84 | Even better, your data requirements are written in a declarative fashion, so its easy to see what you component will get.
85 | 


--------------------------------------------------------------------------------
/recipes/at-live.md:
--------------------------------------------------------------------------------
 1 | # @live
 2 | 
 3 | ```
 4 | @live
 5 | ```
 6 | 
 7 | A decorator for enabling subscriptions in queries.
 8 | 
 9 | Basic example:
10 | 
11 | ```js
12 | const string = `
13 | query {
14 |   simpleUser: user @live {
15 |     id
16 |     name
17 |   }
18 | }`;
19 | 
20 | const options = {
21 |   variables: {foo: 1},
22 |   resolveChannelKey: {
23 |     simpleUser: (source, args) => args.foo
24 |   }
25 | }
26 | 
27 | function mapStateToProps() {
28 |   return {
29 |     userQuery: cashay.query(string, options)
30 |   }
31 | }
32 | ```
33 | 
34 | In this example, we have a GraphQL subscription named `user` on the server.
35 | This subscription returns a fixed set of fields.
36 | By returning a fixed set of fields, you can optimize how the server handles these queries (skip parsing, validation, etc).
37 | As is common, you may only need a field or 2 for a basic component, but then ALL the fields for the User Dashboard.
38 | In that case, set your server up so they are 2 different channels.
39 | For example, `user/123` gives you all the fields and `simpleUser/123` just gives you `id, name, picture`.
40 | The field alias, `simpleUser` gets passed to your `subscriber` function as the channel name to make this easy.
41 | 
42 | By default, `resolveChannelKey` will return `source.id` or the value of the first argument, 
43 | which is almost always what you want, anyways.
44 | 
45 | 
46 | Now let's study a real-world production example:
47 | ```js
48 | const string = `
49 | query {
50 |   teamMembers(teamId: $teamId) @live {
51 |     id
52 |     name
53 |     picture
54 |     projects @live {
55 |       id
56 |       content
57 |     }
58 |   }  
59 | }`
60 | 
61 | const options = {
62 |   variables: {teamId: '123'}
63 | }
64 | ```
65 | The above will begin a subscription that returns an array of team members on a team.
66 | _Then_, for each team member, it will start a subscription for her projects, resulting in n+1 subscriptions.
67 | Since no `resolveChannelKey` was provided for `teamMembers`, 
68 | it will take the value of first argument. Since the first arg is `teamId`, the key will be `123`.
69 | 
70 | Assume that the `projects` subscription takes in a `teamMemberId` argument on the server.
71 | The channel will be something like `projects/${teamMemberId}`.
72 | Since we don't know that at the time this query is called, we can't pass in an argument.
73 | But remember, by default it will use `source.id` as the key. 
74 | Since `teamMembers` is the source, it will use `teamMember.id`.
75 | As new people join your team, their projects will be subscribed to, automatically.
76 |  
77 | If we wanted to use the teamMember's name, we would write something like: 
78 | ```js
79 | resolveChannelKey: {
80 |   projects: source => source.name
81 | }
82 | ``` 
83 | 


--------------------------------------------------------------------------------
/recipes/cashay-schema.md:
--------------------------------------------------------------------------------
 1 | # cashay-schema
 2 | 
 3 | The CLI script takes an `input` and an `output`:
 4 | - `input`: The relative path to
 5 | your server schema. Alternatively, you can pass in the url to a GraphQL endpoint
 6 | - `output`: The relative path to your output file. Defaults to
 7 | `./clientSchema.json`
 8 | 
 9 | Options:
10 | - `--production`: Removes whitespaces from the generated `clientSchema.json`
11 | - `--oncomplete`: A relative path to a callback to run after
12 | generation is complete. This is useful if you need to drain a DB connection
13 | pool:
14 | 
15 | ```js
16 | // drainPool.js
17 | import r from './rethinkDBDriver';
18 | export default () => {
19 |   r.getPoolMaster().drain();
20 | }
21 | ```
22 | 
23 | **Pro tip: Make it an npm script:**
24 | 
25 | `"updateSchema": "cashay-schema src/schema.js src/clientSchema.json --oncomplete src/drainPool.js --production"`
26 | 
27 | 


--------------------------------------------------------------------------------
/recipes/multi-part-queries.md:
--------------------------------------------------------------------------------
 1 | # Multi-part queries
 2 | 
 3 | Sometimes, it is preferable to sacrifice a round trip in exchange for a smaller payload.
 4 | In such a case, you'd want to perform a 2-part query.
 5 | 
 6 | In the same operation, you would have 2 queries.
 7 | The first query would be something like `getPostIds`,
 8 | which would return an array like `['123', '124', '125']`.
 9 | 
10 | The second query would be something like `getPostsByIds`,
11 | which accepts a required array of IDs `($IDs: [ID!]!)`
12 | 
13 | then your variables might look like `{IDs: (response, cashayState) => response.getPostIds}`
14 | If you pass in a function for a variable, cashay will try to find it in the response from the query.
15 | It's here that you can perform a filter against what you already have, eg `cashayState.entities.Posts`.
16 | 
17 | Since `IDs` will be falsy for the first pass, that query will be removed from initial server request.
18 | Then, after the response comes back, `getPostIds` will be removed from the second server request
19 | since that piece was returned locally.
20 | 
21 | In other words, Cashay asks for as much data as possible as soon as possible,
22 | but never asks the server for something it already has.
23 | 


--------------------------------------------------------------------------------
/recipes/pagination.md:
--------------------------------------------------------------------------------
 1 | # Pagination
 2 | 
 3 | Cashay uses cursor-based pagination.
 4 | That means your backend queries should accept `last, before` and/or `first, after` arguments.
 5 | Of course, naming is up to you (although it must be consistent across your whole backend).
 6 | Each returned document should also include a field called `cursor` that contains the cursor used by your database
 7 | in conjunction with `before, after`.
 8 | - `first`: The number of documents you want to receive _starting from the beginning of the array_.
 9 | - `last`: The number of documents you want to receive _starting from the end of the array_.
10 | - `after`: The cursor of the document prior to the one you want. `first` will start counting at `after + 1`.
11 | - `before`: Similar to `after`, but starting from the back of the array.
12 |  For example, you want the _least_ recent posts on a query called `getRecentPosts`.
13 | 
14 | Cashay manages cursors for you.
15 | All you have to do is request `first` or `last` (but not both!).
16 | Behind the scenes, it will add the cursor and reduce the amount fetched.
17 | For example, start by requesting 10 by passing in a `variables` object like `{first: 10}`.
18 | Then when you want more, call `setVariables` and change the value to `20`.
19 | Cashay will see that you already have the first 10 and only request the next 10 starting with the cursor of the last document you have.
20 | Cashay enforces best practices and only supports querys that start from the beginning or end.
21 | It will throw an error if you try to use the cursor within your queries.
22 | 
23 | ## Starting from the middle of a query
24 | 
25 | Rarely, you'll need to start from the middle of a query.
26 | For example, you have a chat search feature that returns the search result with the 10 chat lines above & below it.
27 | Cashay currently offers 2 ways to accomplish this:
28 | 1. Use the ultra-efficient 2-part query method as shown above
29 | 2. Treat the result as a separate array.
30 | This will fetch possibly redundant documents (especially if you return multiple search results)
31 | but an extra couple bytes is a fair trade for the speed & simplicity.
32 | 
33 | ## Detecting if all documents have been fetched
34 | 
35 | When paginating, it is useful to detect when there are no additional new docs left on the server.
36 | Almost always, you can accomplish this by comparing the amount requested to the amount received.
37 | For example, if you have 15 documents on the server & request them 10 at a time,
38 | you know you've run out when the second request for 10 only returns 5.
39 | However, this heuristic fails when you have 20 documents on the server because after the 2nd request
40 | the second request will have returned 10, as expected, but there are no additional documents left to fetch.
41 | To fix this, you have 2 options:
42 | 1. Have your server return n+1 documents. In doing so, you locally return an unseen document immediately
43 | which makes for a beautifully responsive UI.
44 | 2. Have your server return n documents + a `null`. Doing so increases the array length by 1, but is otherwise ignored.
45 | This is likely only useful if you care more about payload size than UI.
46 | 


--------------------------------------------------------------------------------
/recipes/persisted-state.md:
--------------------------------------------------------------------------------
 1 | # Persisted state
 2 | 
 3 | Cashay is just a reducer, so it doesn't need any extra logic to persist data locally.
 4 | Any tool you use to persist your redux store will work for persisting your domain state, too!
 5 | 
 6 | Personally, I like using [redux-persist](https://github.com/rt2zz/redux-persist).
 7 | Redux-persist works by storing each reducer in in a key-value store like
 8 | `localStorage`, `localForage`, or React-native storage.
 9 | After each action is dispatched, it will update your locally-stored copy, too.
10 | When your app starts up, you can rehydrate the persisted data back into your redux state.
11 | 
12 | A production setup might look like this:
13 | 
14 | ```
15 | persistStore(store, {transforms: [cashayPersistTransform]}, () => {
16 |   cashay.create({
17 |     store,
18 |     schema: cashaySchema,
19 |     transport: new HTTPTransport(...);
20 |   });
21 |   render(
22 |     <AppContainer>
23 |       <Root store={store}/>
24 |     </AppContainer>,
25 |     document.getElementById('root')
26 |   );
27 | });
28 | ```
29 | 
30 | A more advanced feature is removing stale data during rehydration, such as old query data.
31 | That's what the `cashayPersistTransform` does above.
32 | For example, if you use Cashay for authorization,
33 | you might want to remove an expired JWT from a `getUserWithAuthToken` query:
34 | 
35 | ```
36 | import {createTransform} from 'redux-persist';
37 | import jwtDecode from 'jwt-decode';
38 | 
39 | const cashayDeserializer = outboundState => {
40 |   const auth = outboundState.data.result.getUserWithAuthToken;
41 |   if (auth) {
42 |     const authObj = auth[''];
43 |     const {authToken} = authObj;
44 |     if (authToken) {
45 |       const authTokenObj = jwtDecode(authToken);
46 |       if (authTokenObj.exp < Date.now() / 1000) {
47 |         authObj.authToken = null;
48 |       }
49 |     }
50 |   }
51 |   return outboundState;
52 | };
53 | 
54 | export default createTransform(
55 |   state => state,
56 |   cashayDeserializer,
57 |   {whitelist: ['cashay']}
58 | );
59 | ```
60 | Note: Cashay stores data using the following pattern:
61 | ```
62 | cashay.data.result[queryName][?arguments][?pagination]
63 | ```
64 | You can verify this path by cracking open your friendly `redux-devtools`.
65 | 
66 | In the future, when time-to-live (TTL) metadata is supported,
67 | Cashay will include a transfrom that will automatically delete all expired documents.
68 | 


--------------------------------------------------------------------------------
/recipes/subscriber.md:
--------------------------------------------------------------------------------
 1 | # Subscriber
 2 | 
 3 | ```
 4 | subscriber(channel, key, handlers)
 5 | ```
 6 | 
 7 | - `channel`: The alias or field name next to your @live directive. 
 8 | This typically serves as the base channel for your sub. In `post/123` it would be `post`.
 9 | - `key`: The variables that you passed into the `subscribe` call. In `post/123` it would be `123`. 
10 | - `handlers`: An object containing the following:
11 |   - `add(doc, handlerOptions)`: A function that takes a new doc. Cashay will append it to the end of the stream.
12 |   - `update(doc, handlerOptions)`: A function that takes a doc diff. 
13 |  You only need to supply it with the fields that have changed.
14 |   - `upsert(doc, handlerOptions)`: A function that will call `update` if the doc exists, else `add`.
15 |  Preferred over `add` since `add` could sneak some duplicates in if a socket reconnects.
16 |   - `remove(id, handlerOptions)`: A function that will remove the document with the given ID
17 |   - `setStatus(newStatus)`: A function that will set the status of your subscription to whatever you want.
18 |   This is useful, for example, if the docs coming down the wire are already in the DB, then you can set it to
19 |   `initializing` and your front-end can react accordingly.
20 | 
21 | As shown above, each handler takes an object called `handlerOptions`, which has a single field: 
22 | - `removeKeys`: If you'd like to remove a key from an object, pass in an array of fields to remove.
23 | e.g. `['milk', 'soda']`.
24 | 
25 | Basic example:
26 | ```js
27 | function subscriber(channel, key, handlers) {
28 |   // compose your channel name how you like. I like the conventional REST-ish slash delimiter (eg `comments/123`)
29 |   const channelName = `${channel}/${key}`;
30 |   
31 |   // connect using your favorite socket client (socketCluster, socket.io, sockJS, ws)
32 |   const socket = socketCluster.connect();
33 |   
34 |   const {upsert, update, remove} = handlers;
35 |   
36 |   // subscribe to the channel. Other socket APIs might just use `emit`
37 |   socket.subscribe(channelName, {waitForAuth: true});
38 |   
39 |   // your server should probably send back something that tells you what to do with the data
40 |   // in this example, the server knows if a document has been added/removed/changed in the database
41 |   socket.on(channelName, data => {
42 |     if (data.type === 'add') {
43 |       upsert(data.fields);
44 |     } else if (data.type === 'remove') {
45 |       remove(data.id);
46 |     } else {
47 |       update(data.fields, {removeKeys: data.removeKeys});
48 |     }
49 |   });
50 |   
51 |   // you can do anything else here, too
52 |   socket.on('unsubscribe', unsubChannel => {
53 |     if (unsubChannel === channelName) {
54 |       console.log(`unsubbed from ${unsubChannel}`);
55 |     }
56 |   });
57 |   
58 |   // you should return a function that will end this subscription
59 |   return () => socket.unsubscribe(channelName);
60 | }
61 | ```
62 | 


--------------------------------------------------------------------------------
/recipes/subscriptions.md:
--------------------------------------------------------------------------------
 1 | # Subscriptions
 2 | 
 3 | Subscriptions usually mean sockets, which means client state is kept on the server.
 4 | It also means tying your backend to a pubsub, whether that is built-in (like RethinkDB),
 5 | a message queue (like redis or RabbitMQ), or something built into your socket engine (SocketCluster).
 6 |  
 7 | With all these variables, it's hard to decide which strategy is universally the best.
 8 | I've decided that the best solution is the one where the query string represents how you want your data to look.
 9 | This forces your data to accurately reflect your GraphQL schema.
10 | I'll write more here as the ideas get flushed out further.
11 | 
12 | 
13 | # LEGACY PATTERNS (NOT POSSIBLE IN CURRENT VERSION)
14 | 
15 | ## Single-table changefeeds
16 | 
17 | Assuming you have something like RethinkDB that will push a message every time a row in a database
18 | table is mutated, you can subscribe to this. For every `n` times you call `cashay.subscribe`, your
19 | server has `n` open subscriptions. This option is great because it is simple, but not so great because
20 | the data comes in different streams. While this keeps the payload size down, you must join the streams
21 | in the application layer, which isn't the most intuitive place to do it.
22 | 
23 | ## Multi-table changefeeds
24 | 
25 | Very specific to RethinkDB, you can execute a changefeed on a table join. 
26 | This allows for a much smaller number of subscriptions to manage.
27 | However, it isn't as granular and requires logic on the server to diff the data
28 | and return that diff to the client.
29 | It also makes a mess of the GraphQL subscription, since that join is pretty static.
30 | 
31 | ## Schema-triggered subscriptions
32 | 
33 | A GraphQL schema has many fields. Those fields know if the root operation is a `subscription` and can act accordingly. 
34 | For example, inside a `Post` subscription, I can see if the incoming query wants the `comments` fields.
35 | On that comments field, if the `ref.operation.operaton === 'subscription'` then I can open a new changefeed.
36 | Then, I would pass in a `path` stack to grow it so I know that `comments` is a child of `Post`.
37 | 
38 | ## Real-time event-driven subscriptions
39 | 
40 | An alternative approach to subscriptions is to trigger a query when a trigger is received.
41 | For example, client A updates his avatar, which sends `NEW_AVATAR` message to Client B.
42 | Client B then queries the new avatar for Client A.
43 | Alternatively, Client B can retrigger a specific query with `forceFetch = true`. 
44 | This would result in a larger payload, but less client logic. 
45 | 
46 | 


--------------------------------------------------------------------------------
/recipes/transports.md:
--------------------------------------------------------------------------------
  1 | # Transports
  2 | 
  3 | A transport is a class instance that shuttles data to and from your graphql server.
  4 | For most cases, you'll probably want to transport your data via HTTP.
  5 | However, there are a couple cases where you don't need HTTP;
  6 | namely, if you're using sockets or you're on the serving and using Cashay for server-side rendering (SSR).
  7 | 
  8 | On the trip to the server, the transport attaches any `auth` that you might need and sends the request on its happy way.
  9 | When `data` and `errors` come back from the server, the transport transforms `errors` to `error`
 10 | and sends to result back to Cashay, which in turn populates your redux store with the results.
 11 | 
 12 | ## `errorHandler`
 13 | 
 14 | Notice that GraphQL gives you `errors` and the transport gives Cashay `error`.
 15 | By default, any GraphQL errors that come back from the server are put in an object: `error = {errors}`.
 16 | 
 17 | But the fun doesn't end there. If you throw your own errors in your GraphQL `resolve` function,
 18 | make sure the `Error.message` is a stringified object with an `_error` key.
 19 | The `errorHandler` tries to parse the `Error.message` and if it's an object with `_error`,
 20 | it will set that parsed object as the error in the redux store. You can include multiple errors by simply adding
 21 | more keys to that `Error.message`.
 22 | I'd suggest something like `{_error: 'Invalid login', type: 'password', subtype: 'password too weak'}`
 23 | 
 24 | To me, this is the cleanest way to handle GraphQL's awkward error handling.
 25 | However, if you know of a better way, please PLEASE open an issue!
 26 | And in the mean time, you can simply pass in your own custom `errorHandler` as the last param for either transport.
 27 | 
 28 | ## HTTPTransport
 29 | 
 30 | ```js
 31 | new HTTPTransport(uri, fetchOptions, errorHandler)
 32 | ```
 33 | 
 34 | - *`uri`: the location of your graphQL endpoint, defaults to '/graphql'
 35 | - `fetchOptions`: Any details or headers used to pass into making the HTTP fetch
 36 | - `errorHandler`: A custom function that handles your errors from GraphQL or the fetch itself
 37 | 
 38 | Example:
 39 | ```js
 40 | import {HTTPTransport} from 'cashay';
 41 | const Authorization = `Bearer ${authToken}`;
 42 | const transport = new HTTPTransport('/myEndpoint', {headers: {Authorization}});
 43 | ```
 44 | 
 45 | If you'd like to replace the global `cashay.httpTransport`, you can call just call `cashay.create({httpTransport: newTransport})`.
 46 | This is useful if your `fetchOptions` change, for example the client gets a renewed `authToken`.
 47 | 
 48 | ## Transport
 49 | 
 50 | ```js
 51 | new Transport(sendToServer, errorHandler)
 52 | ```
 53 | 
 54 | - *`sendToServer(request)`: a function that takes in a request (where `request = {queryString, variables}`)
 55 | and returns a `Promise` that resolves with a GraphQL response.
 56 | - `errorHandler`: A custom function that handles your errors from GraphQL or the fetch itself
 57 | 
 58 | Example #1 Server-side Rendering (SSR):
 59 | ```js
 60 | import {graphql} from 'graphql';
 61 | import Schema from './rootSchema';
 62 | import {Transport} from 'cashay';
 63 | const graphQLHandler = function({query, variables}) => {
 64 |   return graphql(Schema, query, null, null, variables);
 65 | }
 66 | const transport = new Transport(graphQLHandler);
 67 | ```
 68 | This is useful for server-side rendering and don't want cashay to make an HTTP roundtrip to itself.
 69 | Alternatively, for demo apps with in-memory databases, it makes sense to keep GraphQL on the client for easy debugging.
 70 | 
 71 | Example #2: A socket that offers an `emit` callback
 72 | 
 73 | ```js
 74 | import {Transport} from 'cashay';
 75 | import {socket} from './myCustomSocketDriver';
 76 | 
 77 | const sendToServer = request => {
 78 |   return new Promise((resolve) => {
 79 |     socket.emit('graphql', request, (error, response) => {
 80 |       resolve(response);
 81 |     });
 82 |   });
 83 | };
 84 | const transport = new Transport(sendToServer);
 85 | ```
 86 | 
 87 | Example #3: A vanilla websocket
 88 | 
 89 | ```js
 90 | import {Transport} from 'cashay';
 91 | import {socket} from './myCustomSocketDriver';
 92 | 
 93 | const sendToServer = request => {
 94 |   return new Promise((resolve) => {
 95 |     socket.emit('graphqlRequest', request);
 96 |     socket.on('graphqlResponse', response => {
 97 |       resolve(response)
 98 |     })
 99 |   });
100 | };
101 | const transport = new Transport(sendToServer);
102 | ```
103 | 


--------------------------------------------------------------------------------
/src/__tests__/Cashay-data.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mattkrick/cashay/e8e220d033f8eb2d748ef28d45d4c47cdb842054/src/__tests__/Cashay-data.js


--------------------------------------------------------------------------------
/src/__tests__/Cashay-test.js:
--------------------------------------------------------------------------------
1 | import 'babel-register';
2 | import test from 'ava';
3 | import clientSchema from './clientSchema.json';
4 | 
5 | test('caches a partial query result', t => {
6 |   t.is(1,1);
7 | });
8 | 


--------------------------------------------------------------------------------
/src/__tests__/data/authors.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 |   {
 3 |     _id: 'a123',
 4 |     name: 'Matt K',
 5 |     twitterHandle: 's@__mattk'
 6 |   },
 7 |   {
 8 |     _id: 'a124',
 9 |     name: 'Joe J',
10 |     twitterHandle: '@__joej'
11 |   },
12 |   {
13 |     _id: 'a125',
14 |     name: 'Rob R',
15 |     twitterHandle: '@__robr'
16 |   }
17 | ]
18 | 


--------------------------------------------------------------------------------
/src/__tests__/data/comments.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 |   {
 3 |     _id: 'c123',
 4 |     cursor: 'c123',
 5 |     content: 'This is great!',
 6 |     author: 'a125',
 7 |     postId: 'p126',
 8 |     karma: 5,
 9 |     createdAt: 1463074881798
10 |   },
11 |   {
12 |     _id: 'c124',
13 |     cursor: 'c124',
14 |     content: 'Do you want to make $67,000/hr working from home? This single mom can do it!',
15 |     author: 'a124',
16 |     postId: 'p126',
17 |     karma: -100,
18 |     createdAt: 1463078881798
19 |   }
20 | ]
21 | 


--------------------------------------------------------------------------------
/src/__tests__/data/groups.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 |   {
 3 |     name: 'executive team',
 4 |     _id: 'g123',
 5 |     ownerId: 'a123',
 6 |     members: ['a123', 'a124']
 7 |   },
 8 |   {
 9 |     name: 'all employees',
10 |     _id: 'g124',
11 |     ownerId: 'a123',
12 |     members: ['a125', 'g123']
13 |   }
14 | ]
15 | 


--------------------------------------------------------------------------------
/src/__tests__/data/posts.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 |   {
 3 |     _id: 'p123',
 4 |     author: 'a123',
 5 |     content: 'Cashay is neat',
 6 |     title: 'What is cashay?',
 7 |     title_ES: 'What is cashay? EN ESPANOL!',
 8 |     category: 'hot stuff',
 9 |     karma: 2,
10 |     createdAt: 1411111111111,
11 |     cursor: '1411111111111' + 'chikachikow',
12 |     keywordsMentioned: []
13 |   },
14 |   {
15 |     _id: 'p124',
16 |     author: 'a123',
17 |     content: 'Cashay uses the redux store to hold all of its normalized data and variables',
18 |     title: 'Does cashay work with redux?',
19 |     title_ES: 'Does cashay work with redux? EN ESPANOL!',
20 |     category: 'hot stuff',
21 |     karma: 2,
22 |     createdAt: 1422222222222,
23 |     cursor: '1422222222222' + 'chikachikow',
24 |     keywordsMentioned: []
25 |   },
26 |   {
27 |     _id: 'p125',
28 |     author: 'a124',
29 |     content: 'Benchmarks are usually written by people who have a bias. You should write your own (but yes)',
30 |     title: 'Is cashay smaller or faster than relay?',
31 |     title_ES: 'Is cashay smaller or faster than relay? EN ESPANOL!',
32 |     category: 'ice cold',
33 |     karma: 2,
34 |     createdAt: 1433333333333,
35 |     cursor: '1433333333333' + 'chikachikow',
36 |     keywordsMentioned: []
37 |   },
38 |   {
39 |     _id: 'p126',
40 |     author: 'a124',
41 |     content: 'Denormalized data is cached in the cashay singleton',
42 |     title: 'How does cashay store denormalized data?',
43 |     title_ES: 'How does cashay store denormalized data? EN ESPANOL!',
44 |     category: 'hot stuff',
45 |     karma: 2,
46 |     createdAt: 1444444444444,
47 |     cursor: '1444444444444' + 'chikachikow',
48 |     keywordsMentioned: [
49 |       {
50 |         word: 'cashay'
51 |       },
52 |       {
53 |         word: 'neat'
54 |       }
55 |     ]
56 |   }
57 | ]
58 | 


--------------------------------------------------------------------------------
/src/__tests__/parseSortPrint.js:
--------------------------------------------------------------------------------
 1 | import {parse} from 'graphql/language/parser';
 2 | import {print} from 'graphql/language/printer';
 3 | import {teardownDocumentAST} from '../utils';
 4 | /**
 5 |  * This is a stupid little function that sorts fields by alias & then by name
 6 |  * That way, testing equality is easy
 7 |  */
 8 | export const parseSortPrint = graphQLString => {
 9 |   const ast = parse(graphQLString, {noLocation: true, noSource: true});
10 |   return sortPrint(ast);
11 | };
12 | 
13 | export const sortPrint = ast => {
14 |   const {operation} = teardownDocumentAST(ast.definitions);
15 |   recurse(operation.selectionSet.selections);
16 |   return print(ast);
17 | };
18 | 
19 | export const sortAST = ast => {
20 |   const {operation} = teardownDocumentAST(ast.definitions);
21 |   recurse(operation.selectionSet.selections);
22 |   return ast;
23 | };
24 | 
25 | const recurse = astSelections => {
26 |   for (let selection of astSelections) {
27 |     if (selection.selectionSet) {
28 |       recurse(selection.selectionSet.selections);
29 |     }
30 |   }
31 |   astSelections.sort(sortFields);
32 | };
33 | 
34 | // if true, b moves forward
35 | const sortFields = (a,b) => {
36 |   if (a.alias) {
37 |     if (b.alias) {
38 |       // if both have aliases, sort them alphabetically
39 |       return a.alias.value > b.alias.value
40 |     }
41 |     // if a has an alias, put it ahead of b
42 |     return false;
43 |   } else if (b.alias) {
44 |     // if b has an alias, put it ahead of a
45 |     return true;
46 |   }
47 |   if (a.name) {
48 |     if (b.name) {
49 |       // if both have names, sort them alphabetically
50 |       return a.name.value > b.name.value;
51 |     }
52 |     // if a has a name, put it ahead of b
53 |     return false;
54 |   } else if (b.name) {
55 |     // if b has a name, put it ahead of a
56 |     return true;
57 |   }
58 |   if (a.selectionSet) {
59 |     if (b.selectionSet) {
60 |       // if both are inline frags, sort by the length
61 |       return a.selectionSet.selections.length > b.selectionSet.selections.length
62 |     }
63 |     return false;
64 |   } else if (b.selectionSet) {
65 |     return true
66 |   }
67 | };
68 | // inline frags don't have names, so just stick em at the end
69 | // const sortField = field => (field.alias && field.alias.value) ||
70 | // (field.name && field.name.value) ||
71 | // (field.selectionSet.selections[0].name && field.selectionSet.selections[0].name.value) ||
72 | // Infinity;
73 | 


--------------------------------------------------------------------------------
/src/createVariableDefinitions.js:
--------------------------------------------------------------------------------
 1 | import {ensureRootType, makeNamespaceString} from './utils';
 2 | import {VARIABLE, OBJECT} from 'graphql/language/kinds';
 3 | import {VariableDefinition} from './helperClasses';
 4 | 
 5 | export default function createVariableDefinitions(argsToDefine, fieldSchema, isNamespaced, context) {
 6 |   const {initialVariableDefinitions, op, opStateVars, schema} = context;
 7 |   const variableDefinitions = [];
 8 |   const variableEnhancers = [];
 9 |   const bagArgs = (argsToDefine, fieldSchema) => {
10 |     for (let i = 0; i < argsToDefine.length; i++) {
11 |       const arg = argsToDefine[i];
12 |       const argName = arg.name.value;
13 |       const argKind = arg.value.kind;
14 |       if (argKind === VARIABLE) {
15 |         const variableName = arg.value.name.value;
16 |         const variableDefOfArg = initialVariableDefinitions.find(def => def.variable.name.value === variableName);
17 |         if (isNamespaced) {
18 |           // namespace the variable definitions & create the enhancer for each
19 |           const namespaceKey = makeNamespaceString(op, variableName);
20 |           if (!variableDefOfArg) {
21 |             const newVariableDef = makeVariableDefinition(argName, namespaceKey, fieldSchema);
22 |             variableDefinitions.push(newVariableDef);
23 |           }
24 |           const variableEnhancer = enhancerFactory(opStateVars, variableName, namespaceKey);
25 |           variableEnhancers.push(variableEnhancer);
26 |         } else if (!variableDefOfArg) {
27 |           const newVariableDef = makeVariableDefinition(argName, variableName, fieldSchema);
28 |           variableDefinitions.push(newVariableDef);
29 |         }
30 |       } else if (argKind === OBJECT) {
31 |         const argSchema = fieldSchema.args[argName];
32 |         const rootArgType = ensureRootType(argSchema.type);
33 |         const subSchema = schema.types[rootArgType.name];
34 |         bagArgs(arg.value.fields, subSchema);
35 |       }
36 |     }
37 |   };
38 |   bagArgs(argsToDefine, fieldSchema);
39 |   return {variableDefinitions, variableEnhancers};
40 | 
41 | };
42 | 
43 | const makeVariableDefinition = (argName, variableName, fieldSchema) => {
44 |   // we're not sure whether we're inside an arg or an input object
45 |   const fields = fieldSchema.args || fieldSchema.inputFields;
46 |   const argSchema = fields[argName];
47 |   if (!argSchema) {
48 |     throw new Error(`Invalid argument: ${argName}`);
49 |   }
50 |   return new VariableDefinition(variableName, argSchema.type);
51 | };
52 | 
53 | const enhancerFactory = (opStateVars, variableName, namespaceKey) => {
54 |   return variablesObj => {
55 |     return {
56 |       ...variablesObj,
57 |       [namespaceKey]: opStateVars[variableName]
58 |     }
59 |   }
60 | };
61 | 


--------------------------------------------------------------------------------
/src/helperClasses.js:
--------------------------------------------------------------------------------
  1 | import {
  2 |   OPERATION_DEFINITION,
  3 |   DOCUMENT,
  4 |   SELECTION_SET,
  5 |   NAME,
  6 |   ARGUMENT,
  7 |   VARIABLE,
  8 |   NAMED_TYPE,
  9 |   FIELD,
 10 |   VARIABLE_DEFINITION,
 11 |   LIST_TYPE,
 12 |   NON_NULL_TYPE
 13 | } from 'graphql/language/kinds';
 14 | import {TypeKind} from 'graphql/type/introspection';
 15 | import {SET_VARIABLES} from './normalize/duck';
 16 | import denormalizeStore from './normalize/denormalizeStore';
 17 | import parseAndInitializeQuery from './query/parseAndInitializeQuery';
 18 | import {getStateVars, parse, LOADING, COMPLETE} from './utils';
 19 | 
 20 | const {LIST, NON_NULL} = TypeKind;
 21 | 
 22 | export class CachedMutation {
 23 |   constructor() {
 24 |     this.fullMutation = undefined;
 25 |     this.activeQueries = {};
 26 |     this.variableEnhancers = [];
 27 |     this.variableSet = new Set();
 28 |     this.singles = {};
 29 |   }
 30 | 
 31 |   clear(clearSingles) {
 32 |     this.fullMutation = undefined;
 33 |     this.variableEnhancers = [];
 34 |     this.variableSet.clear();
 35 |     if (clearSingles) {
 36 |       this.singles = {};
 37 |     }
 38 |   }
 39 | }
 40 | 
 41 | export class CachedSubscription {
 42 |   constructor(subscriptionString, key, deps) {
 43 |     this.ast = parse(subscriptionString);
 44 |     this.deps = deps;
 45 |     this.responses = {
 46 |       [key]: {}
 47 |     };
 48 |   }
 49 | }
 50 | 
 51 | export class CachedQuery {
 52 |   constructor(queryString, schema, idFieldName, refetch, key) {
 53 |     this.ast = parseAndInitializeQuery(queryString, schema, idFieldName);
 54 |     this.refetch = refetch;
 55 |     this.responses = {
 56 |       [key]: {}
 57 |     };
 58 |   }
 59 | 
 60 |   /**
 61 |    * create a denormalized document from local data
 62 |    * it also turns frags to inline, and flags missing objects and variableDefinitions in context.operation
 63 |    */
 64 |   createResponse(context, op, key, dispatch, getState, forceFetch) {
 65 |     const data = denormalizeStore(context);
 66 |     const isComplete = !forceFetch && !context.operation.sendToServer;
 67 |     this.responses[key] = {
 68 |       data,
 69 |       setVariables: this.setVariablesFactory(op, key, dispatch, getState),
 70 |       status: isComplete ? COMPLETE : LOADING
 71 |     };
 72 |   }
 73 | 
 74 |   setVariablesFactory(op, key, dispatch, getState) {
 75 |     return cb => {
 76 |       // trigger an invalidation
 77 |       this.responses[key] = undefined;
 78 |       const cashayState = getState();
 79 |       const stateVars = getStateVars(cashayState, op, key) || {};
 80 |       const variables = {
 81 |         ...stateVars,
 82 |         ...cb(stateVars)
 83 |       };
 84 |       const payload = {ops: {[op]: {[key]: {variables}}}};
 85 | 
 86 |       // trigger a recompute
 87 |       dispatch({
 88 |         type: SET_VARIABLES,
 89 |         payload
 90 |       });
 91 |     }
 92 |   }
 93 | }
 94 | 
 95 | class SelectionSet {
 96 |   constructor(selections = []) {
 97 |     this.kind = SELECTION_SET;
 98 |     this.selections = selections;
 99 |   }
100 | }
101 | 
102 | export class Name {
103 |   constructor(value) {
104 |     this.kind = NAME;
105 |     this.value = value;
106 |   }
107 | }
108 | 
109 | export class Field {
110 |   constructor({alias, args, directives, name, selections}) {
111 |     this.kind = FIELD;
112 |     this.alias = alias;
113 |     this.arguments = args;
114 |     this.directives = directives;
115 |     this.name = new Name(name);
116 |     this.selectionSet = selections ? new SelectionSet(selections) : null;
117 |   }
118 | }
119 | export class MutationShell {
120 |   constructor(mutationName, mutationArgs = [], variableDefinitions = [], isEmpty) {
121 |     this.kind = DOCUMENT;
122 |     this.definitions = [{
123 |       kind: OPERATION_DEFINITION,
124 |       operation: 'mutation',
125 |       variableDefinitions,
126 |       directives: [],
127 |       selectionSet: new SelectionSet([new Field({
128 |         args: mutationArgs,
129 |         name: mutationName,
130 |         selections: isEmpty ? null : []
131 |       })])
132 |     }]
133 |   }
134 | }
135 | 
136 | export class RequestArgument {
137 |   constructor(nameValue, valueKind, valueValue) {
138 |     this.kind = ARGUMENT;
139 |     this.name = new Name(nameValue);
140 |     this.value = {
141 |       kind: valueKind
142 |     };
143 |     if (valueKind === VARIABLE) {
144 |       this.value.name = new Name(valueValue);
145 |     } else {
146 |       this.value.value = valueValue
147 |     }
148 |   }
149 | }
150 | 
151 | export class VariableDefinition {
152 |   constructor(variableName, argType) {
153 |     this.kind = VARIABLE_DEFINITION;
154 |     this.type = processArgType(argType);
155 |     this.variable = {
156 |       kind: VARIABLE,
157 |       name: new Name(variableName)
158 |     }
159 |   }
160 | }
161 | 
162 | const processArgType = argType => {
163 |   const vardefType = {};
164 |   if (argType.kind === NON_NULL) {
165 |     vardefType.kind = NON_NULL_TYPE;
166 |     vardefType.type = processArgType(argType.ofType);
167 |   } else if (argType.kind === LIST) {
168 |     vardefType.kind = LIST_TYPE;
169 |     vardefType.type = processArgType(argType.ofType);
170 |   } else {
171 |     vardefType.kind = NAMED_TYPE;
172 |     vardefType.name = new Name(argType.name)
173 |   }
174 |   return vardefType;
175 | };
176 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | import 'regenerator-runtime/runtime';  // Required for babel plugin transform-async-to-generator
2 | 
3 | export cashayReducer from './normalize/duck';
4 | export cashay from './Cashay';
5 | export HTTPTransport from './transports/HTTPTransport';
6 | export Transport from './transports/Transport';
7 | export transformSchema from './schema/transformSchema';
8 | 


--------------------------------------------------------------------------------
/src/mutate/ActiveQueries.js:
--------------------------------------------------------------------------------
 1 | import {isObject} from '../utils';
 2 | 
 3 | export default class ActiveQueries {
 4 |   constructor(mutationName, possibleComponentObj, cachedQueries, mutationHandlers) {
 5 |     isObject(possibleComponentObj) ? this.makeDefinedComponentsToUpdate(cachedQueries, possibleComponentObj) :
 6 |       this.makeDefaultComponentsToUpdate(cachedQueries, mutationName, mutationHandlers);
 7 |   }
 8 | 
 9 |   makeDefinedComponentsToUpdate(cachedQueries, possibleComponentObj) {
10 |     const possibleComponentKeys = Object.keys(possibleComponentObj);
11 |     for (let i = 0; i < possibleComponentKeys.length; i++) {
12 |       const op = possibleComponentKeys[i];
13 |       if (cachedQueries[op]) {
14 |         // remove falsy values, bring over the key or true
15 |         this[op] = possibleComponentObj[op] === true ? '' : possibleComponentObj[op];
16 |       }
17 |     }
18 |   }
19 | 
20 |   makeDefaultComponentsToUpdate(cachedQueries, mutationName, mutationHandlers) {
21 |     const mutationHandlerObj = mutationHandlers[mutationName] || {};
22 |     // if (!mutationHandlerObj) {
23 |     //   throw new Error(`Did you forget to add mutation handlers to your queries for ${mutationName}?`)
24 |     // }
25 |     const listeningOps = Object.keys(mutationHandlerObj);
26 |     for (let i = 0; i < listeningOps.length; i++) {
27 |       const op = listeningOps[i];
28 |       if (cachedQueries[op]) {
29 |         const {responses} = cachedQueries[op];
30 |         const listeningKeys = Object.keys(responses);
31 |         if (listeningKeys.length === 1) {
32 |           this[op] = listeningKeys[0];
33 |         } else if (listeningKeys.length > 1) {
34 |           throw new Error(`${op} has more than 1 instance.
35 |           For ${mutationName}, please include an 'ops' object in your options`)
36 |         }
37 |       }
38 |     }
39 |   }
40 | };
41 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/createMutationFromQuery-data.js:
--------------------------------------------------------------------------------
  1 | 
  2 | export const queryCommentsForPostId = `
  3 | query($postId: String!) {
  4 |   comments: getCommentsByPostId(postId: $postId) {
  5 |     _id
  6 |   }
  7 | }`;
  8 | 
  9 | export const mutationForCommentQueryNoVars = `
 10 | mutation {
 11 |   createComment {
 12 |     _id
 13 |   }
 14 | }`;
 15 | 
 16 | export const mutationForCommentQuery = `
 17 | mutation {
 18 |   createComment (_id: $_id, postId: $postId, content: $content) {
 19 |     _id
 20 |   }
 21 | }`;
 22 | 
 23 | export const queryMultipleComments = `
 24 | query($postId: String!, $postId2: String!) {
 25 |   comments: getCommentsByPostId(postId: $postId) {
 26 |     _id
 27 |   }
 28 |   comments2: getCommentsByPostId(postId: $postId2) {
 29 |     createdAt
 30 |   }
 31 | }`;
 32 | 
 33 | export const mutationForMultipleComments = `
 34 | mutation {
 35 |   createComment (_id: $_id, postId: $postId, content: $content) {
 36 |     _id
 37 |     createdAt
 38 |   }
 39 | }`;
 40 | 
 41 | export const queryPost = `
 42 |   query($first: Int!) {
 43 |     getRecentPosts(count: $first) {
 44 |       _id,
 45 |     }
 46 |   }`;
 47 | 
 48 | export const mutatePost = `
 49 | mutation {
 50 |   createPost {
 51 |     post {
 52 |       _id
 53 |     }
 54 |   }
 55 | }`;
 56 | 
 57 | export const queryPostWithFieldVars = `
 58 |   query($first: Int!, $defaultLanguage: String, $secondaryLanguage: String) {
 59 |     getRecentPosts(count: $first) {
 60 |       title(language: $defaultLanguage),
 61 |       secondaryTitle: title(language: $secondaryLanguage)
 62 |     }
 63 |   }`;
 64 | 
 65 | export const mutatePostWithFieldVars = `
 66 | mutation {
 67 |   createPost {
 68 |     post {
 69 |       title(language: $defaultLanguage),
 70 |       secondaryTitle: title(language: $secondaryLanguage)
 71 |     }
 72 |   }
 73 | }`;
 74 | 
 75 | export const queryPostCount = `
 76 |   query {
 77 |     getPostCount
 78 |   }`;
 79 | 
 80 | export const mutatePostCount = `
 81 | mutation {
 82 |   createPost {
 83 |     postCount
 84 |   }
 85 | }`;
 86 | 
 87 | export const queryPostCountAliased = `
 88 |   query {
 89 |     postCount: getPostCount
 90 |   }`;
 91 | 
 92 | export const queryPostWithInlineFieldVars = `
 93 |   query($first: Int!, $defaultLanguage: String, $secondaryLanguage: String) {
 94 |     getRecentPosts(count: $first) {
 95 |       ... on PostType {
 96 |         title(language: $defaultLanguage),
 97 |         secondaryTitle: title(language: $secondaryLanguage)
 98 |       }
 99 |     }
100 |   }`;
101 | 
102 | export const mutatePostWithInlineFieldVars = `
103 | mutation {
104 |   createPost {
105 |     post {
106 |       ... on PostType {
107 |         title(language: $defaultLanguage),
108 |         secondaryTitle: title(language: $secondaryLanguage)
109 |       }
110 |     }
111 |   }
112 | }`;
113 | 
114 | export const queryMultiplePosts = `
115 | query {
116 |   getLatestPost {
117 |     _id
118 |   }
119 |   getRecentPosts {
120 |     createdAt
121 |   }
122 | }`;
123 | 
124 | export const mutationForMultiplePosts = `
125 | mutation {
126 |   createPost {
127 |     post {
128 |       _id
129 |       createdAt
130 |     }
131 |   }
132 | }`;
133 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/createMutationFromQuery-tests.js:
--------------------------------------------------------------------------------
  1 | import 'babel-register';
  2 | import test from 'ava';
  3 | import clientSchema from '../../__tests__/clientSchema.json';
  4 | import createMutationFromQuery from '../createMutationFromQuery';
  5 | import {parseSortPrint, sortPrint} from '../../__tests__/parseSortPrint';
  6 | import {parse} from '../../utils';
  7 | 
  8 | import {
  9 |   mutationForCommentQuery,
 10 |   mutationForCommentQueryNoVars,
 11 |   mutationForMultipleComments,
 12 |   queryCommentsForPostId,
 13 |   queryMultipleComments,
 14 |   queryPost,
 15 |   mutatePost,
 16 |   queryPostWithFieldVars,
 17 |   mutatePostWithFieldVars,
 18 |   queryPostCount,
 19 |   mutatePostCount,
 20 |   queryPostCountAliased,
 21 |   queryPostWithInlineFieldVars,
 22 |   mutatePostWithInlineFieldVars,
 23 |   queryMultiplePosts,
 24 |   mutationForMultiplePosts
 25 | } from './createMutationFromQuery-data';
 26 | 
 27 | test('creates basic mutation from a query of many comments', t => {
 28 |   const queryAST = parse(queryCommentsForPostId);
 29 |   const expected = parseSortPrint(mutationForCommentQueryNoVars);
 30 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createComment', {}, clientSchema);
 31 |   const actual = sortPrint(actualAST);
 32 |   t.is(actual, expected);
 33 | });
 34 | 
 35 | test('creates arguments from mutation variables', t => {
 36 |   const queryAST = parse(queryCommentsForPostId);
 37 |   const expected = parseSortPrint(mutationForCommentQuery);
 38 |   const variables = {
 39 |     _id: 'a321',
 40 |     postId: 'p123',
 41 |     content: 'X'
 42 |   };
 43 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createComment', variables, clientSchema);
 44 |   const actual = sortPrint(actualAST);
 45 |   t.is(actual, expected);
 46 | });
 47 | 
 48 | test('creates basic mutation from multi-part query', t => {
 49 |   const queryMultipleComments = `
 50 |   query($postId: String!, $postId2: String!) {
 51 |     comments: getCommentsByPostId(postId: $postId) {
 52 |       _id
 53 |     }
 54 |     comments2: getCommentsByPostId(postId: $postId2) {
 55 |       createdAt
 56 |     }
 57 |   }`;
 58 |   const mutationForMultipleComments = `
 59 |   mutation {
 60 |     createComment (_id: $_id, postId: $postId, content: $content) {
 61 |       _id
 62 |       createdAt
 63 |     }
 64 |   }`;
 65 |   
 66 |   const queryAST = parse(queryMultipleComments);
 67 |   const expected = parseSortPrint(mutationForMultipleComments);
 68 |   const variables = {
 69 |     _id: 'a321',
 70 |     postId: 'p123',
 71 |     content: 'X'
 72 |   };
 73 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createComment', variables, clientSchema);
 74 |   const actual = sortPrint(actualAST);
 75 |   t.is(actual, expected);
 76 | });
 77 | 
 78 | test('creates payload mutation including an object', t => {
 79 |   const queryPost = `
 80 |   query($first: Int!) {
 81 |     getRecentPosts(count: $first) {
 82 |       _id,
 83 |     }
 84 |   }`;
 85 |   const mutatePost = `
 86 |   mutation {
 87 |     createPost {
 88 |       post {
 89 |         _id
 90 |       }
 91 |     }
 92 |   }`;
 93 |   const queryAST = parse(queryPost);
 94 |   const expected = parseSortPrint(mutatePost);
 95 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createPost', {}, clientSchema);
 96 |   const actual = sortPrint(actualAST);
 97 |   t.is(actual, expected);
 98 | });
 99 | 
100 | test('throws if no mutation can be created', t => {
101 |   const queryAST = parse(queryPostCount);
102 |   t.throws(() => createMutationFromQuery(queryAST.definitions[0], 'createPost', {}, clientSchema));
103 | });
104 | 
105 | test('creates payload mutation including a scalar matched by name', t => {
106 |   const queryPostCountAliased = `
107 |   query {
108 |     postCount: getPostCount
109 |   }`;
110 |   const mutatePostCount = `
111 |   mutation {
112 |     createPost {
113 |       postCount
114 |     }
115 |   }`;
116 |   const queryAST = parse(queryPostCountAliased);
117 |   const expected = parseSortPrint(mutatePostCount);
118 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createPost', {}, clientSchema);
119 |   const actual = sortPrint(actualAST);
120 |   t.is(actual, expected);
121 | });
122 | 
123 | test('creates payload mutation including an object with args', t => {
124 |   const queryPostWithFieldVars = `
125 |   query($first: Int!, $defaultLanguage: String, $secondaryLanguage: String) {
126 |     getRecentPosts(count: $first) {
127 |       title(language: $defaultLanguage),
128 |       secondaryTitle: title(language: $secondaryLanguage)
129 |     }
130 |   }`;
131 |   const mutatePostWithFieldVars = `
132 |   mutation {
133 |     createPost {
134 |       post {
135 |         title(language: $defaultLanguage),
136 |         secondaryTitle: title(language: $secondaryLanguage)
137 |       }
138 |     }
139 |   }`;
140 |   const queryAST = parse(queryPostWithFieldVars);
141 |   const expected = parseSortPrint(mutatePostWithFieldVars);
142 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createPost', {}, clientSchema);
143 |   const actual = sortPrint(actualAST);
144 |   t.is(actual, expected);
145 | });
146 | 
147 | test('creates payload mutation when query has inline fragment', t => {
148 |   const queryPostWithInlineFieldVars = `
149 |   query($first: Int!, $defaultLanguage: String, $secondaryLanguage: String) {
150 |     getRecentPosts(count: $first) {
151 |       ... on PostType {
152 |         title(language: $defaultLanguage),
153 |         secondaryTitle: title(language: $secondaryLanguage)
154 |       }
155 |     }
156 |   }`;
157 |   const mutatePostWithInlineFieldVars = `
158 |   mutation {
159 |     createPost {
160 |       post {
161 |         ... on PostType {
162 |           title(language: $defaultLanguage),
163 |           secondaryTitle: title(language: $secondaryLanguage)
164 |         }
165 |       }
166 |     }
167 |   }`;
168 |   const queryAST = parse(queryPostWithInlineFieldVars);
169 |   const expected = parseSortPrint(mutatePostWithInlineFieldVars);
170 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createPost', {}, clientSchema);
171 |   const actual = sortPrint(actualAST);
172 |   t.is(actual, expected);
173 | });
174 | 
175 | test('creates payload mutation from multi-part query', t => {
176 |   const queryAST = parse(queryMultiplePosts);
177 |   const expected = parseSortPrint(mutationForMultiplePosts);
178 |   const actualAST = createMutationFromQuery(queryAST.definitions[0], 'createPost', {}, clientSchema);
179 |   const actual = sortPrint(actualAST);
180 |   t.is(actual, expected);
181 | });
182 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/mergeMutations-data.js:
--------------------------------------------------------------------------------
  1 | import {parse} from '../../utils';
  2 | import namespaceMutation from '../namespaceMutation';
  3 | import clientSchema from '../../__tests__/clientSchema.json';
  4 | 
  5 | export const parseAndNamespace = cachedSingles => {
  6 |   return cachedSingles.map((single, idx) => {
  7 |     const ast = parse(single);
  8 |     const componentId = `component${idx}`;
  9 |     const {namespaceAST} = namespaceMutation(ast, componentId, {}, clientSchema);
 10 |     return namespaceAST;
 11 |   });
 12 | };
 13 | 
 14 | export const createCommentWithId = `
 15 |   mutation($postId: String!, $content: String!) {
 16 |     createComment(postId: $postId, content: $content) {
 17 |       _id,
 18 |     }
 19 |   }`;
 20 | 
 21 | export const createCommentWithId2 = `
 22 |   mutation($postId: String!, $content: String!, $_id: String!) {
 23 |     createComment(postId: $postId, content: $content, _id: $_id) {
 24 |       _id,
 25 |     }
 26 |   }`;
 27 | 
 28 | export const createCommentWithContent = `
 29 |   mutation($postId: String!, $content: String!) {
 30 |     createComment(postId: $postId, content: $content) {
 31 |       content
 32 |     }
 33 |   }`;
 34 | 
 35 | export const createPostWithPostTitleAndCount = `
 36 |   mutation {
 37 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
 38 |       post {
 39 |         title
 40 |       }
 41 |       postCount
 42 |     }
 43 |   }`;
 44 | 
 45 | export const createPostWithPostId = `
 46 |   mutation {
 47 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
 48 |       post {
 49 |         _id
 50 |       }
 51 |     }
 52 |   }`;
 53 | 
 54 | export const createPostWithIncompleteArgs = `
 55 |   mutation {
 56 |     createPost(newPost: {_id: "129"}) {
 57 |       post {
 58 |         _id
 59 |       }
 60 |     }
 61 |   }`;
 62 | 
 63 | export const createPostWithBadArgKind = `
 64 |   mutation {
 65 |     createPost(newPost: "foo") {
 66 |       post {
 67 |         _id
 68 |       }
 69 |     }
 70 |   }`;
 71 | 
 72 | export const createPostWithDifferentId = `
 73 |   mutation {
 74 |     createPost(newPost: {_id: "130"}) {
 75 |       post {
 76 |         _id
 77 |       }
 78 |     }
 79 |   }`;
 80 | 
 81 | 
 82 | export const createPostWithSpanishTitle = `
 83 |   mutation {
 84 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
 85 |       post {
 86 |         title(language:"spanish")
 87 |       }
 88 |     }
 89 |   }`;
 90 | 
 91 | export const typedInlineFrag1 = `
 92 | mutation {
 93 |   createPost(newPost: {_id: "129"}) {
 94 |     post {
 95 |       ... on PostType {
 96 |         title
 97 |       }
 98 |     }
 99 |   }
100 | }`;
101 | 
102 | export const typedInlineFrag2 = `
103 | mutation {
104 |   createPost(newPost: {_id: "129"}) {
105 |     post {
106 |       ... on PostType {
107 |         category
108 |       }
109 |     }
110 |   }
111 | }`;
112 | 
113 | export const createPostWithCrazyFrags2 = `
114 | mutation {
115 |   createPost(newPost: {_id: "129", author: "a123", content: "Hii", title:"Sao", category:"hot stuff"}) {
116 |     post {
117 |       ...{
118 |         _id
119 |       }
120 |       ...spreadLevel1
121 |     }
122 |   }
123 | }
124 | fragment spreadLevel1 on PostType {
125 |   	... {
126 |       category
127 |       ...spreadLevel2
128 |     }
129 | }
130 | fragment spreadLevel2 on PostType {
131 |   title(language:"spanish")
132 | }`;
133 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/mergeMutations-tests.js:
--------------------------------------------------------------------------------
  1 | import 'babel-register';
  2 | import test from 'ava';
  3 | import mergeMutations from '../mergeMutations';
  4 | import {parseSortPrint} from '../../__tests__/parseSortPrint';
  5 | 
  6 | import {
  7 |   parseAndNamespace,
  8 |   createCommentWithId,
  9 |   createPostWithPostTitleAndCount,
 10 |   createCommentWithContent,
 11 |   createPostWithDifferentId,
 12 |   createPostWithIncompleteArgs,
 13 |   createPostWithPostId,
 14 |   createPostWithSpanishTitle,
 15 |   typedInlineFrag1,
 16 |   typedInlineFrag2,
 17 |   createCommentWithId2,
 18 |   createPostWithBadArgKind
 19 | } from './mergeMutations-data';
 20 | 
 21 | /* Tests */
 22 | test('throws when merging 2 different mutations', t => {
 23 |   const cachedSingles = parseAndNamespace([createCommentWithId, createPostWithPostTitleAndCount]);
 24 |   t.throws(() => mergeMutations(cachedSingles));
 25 | });
 26 | 
 27 | test('throws when args are of a different kind', t => {
 28 |   const cachedSingles = parseAndNamespace([createPostWithBadArgKind, createPostWithIncompleteArgs]);
 29 |   t.throws(() => mergeMutations(cachedSingles));
 30 | });
 31 | 
 32 | test('merge fields from 2 simple mutation results', t => {
 33 |   const expectedRaw = `
 34 |   mutation($postId: String!, $content: String!) {
 35 |     createComment(postId: $postId, content: $content) {
 36 |       content
 37 |       _id
 38 |     }
 39 |   }`;
 40 |   const expected = parseSortPrint(expectedRaw);
 41 |   const cachedSingles = parseAndNamespace([createCommentWithId, createCommentWithContent]);
 42 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
 43 |   t.is(actual, expected);
 44 | });
 45 | 
 46 | test('merge nested fields from 2 simple payloads', t => {
 47 |   const expectedRaw = `
 48 |   mutation {
 49 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
 50 |       post {
 51 |         _id
 52 |         title
 53 |       }
 54 |       postCount
 55 |     }
 56 |   }`;
 57 |   const expected = parseSortPrint(expectedRaw);
 58 |   const cachedSingles = parseAndNamespace([createPostWithPostTitleAndCount, createPostWithPostId]);
 59 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
 60 |   t.is(actual, expected);
 61 | });
 62 | 
 63 | test('merge mutation args', t => {
 64 |   const expectedRaw = `
 65 |   mutation {
 66 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
 67 |       post {
 68 |         _id
 69 |       }
 70 |     }
 71 |   }`;
 72 |   const expected = parseSortPrint(expectedRaw);
 73 |   const cachedSingles = parseAndNamespace([createPostWithPostId, createPostWithIncompleteArgs]);
 74 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
 75 |   t.is(actual, expected);
 76 | });
 77 | 
 78 | test('throw if incomplete mutation args have different values', t => {
 79 |   const cachedSingles = parseAndNamespace([createPostWithIncompleteArgs, createPostWithDifferentId]);
 80 |   t.throws(() => mergeMutations(cachedSingles));
 81 | });
 82 | 
 83 | test('add an alias when fields have conflicting args', t => {
 84 |   const expectedRaw = `
 85 |   mutation {
 86 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
 87 |       post {
 88 |         CASHAY_component1_title: title(language:"spanish")
 89 |         title
 90 |       }
 91 |       postCount
 92 |     }
 93 |   }`;
 94 |   const expected = parseSortPrint(expectedRaw);
 95 |   const cachedSingles = parseAndNamespace([createPostWithPostTitleAndCount, createPostWithSpanishTitle]);
 96 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
 97 |   t.is(actual, expected);
 98 | });
 99 | 
100 | test('add an alias when fields have conflicting args (reverse order)', t => {
101 |   const expectedRaw = `
102 |   mutation {
103 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
104 |       post {
105 |         CASHAY_component0_title: title(language:"spanish")
106 |         title
107 |       }
108 |       postCount
109 |     }
110 |   }`;
111 |   const expected = parseSortPrint(expectedRaw);
112 |   const cachedSingles = parseAndNamespace([createPostWithSpanishTitle, createPostWithPostTitleAndCount]);
113 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
114 |   t.is(actual, expected);
115 | });
116 | 
117 | test('merge a typed inline fragment into an existing one', t => {
118 |   const expectedRaw = `
119 |   mutation {
120 |     createPost(newPost: {_id: "129"}) {
121 |       post {
122 |         ... on PostType {
123 |           title
124 |           category
125 |         }
126 |       }
127 |     }
128 |   }`;
129 |   const expected = parseSortPrint(expectedRaw);
130 |   const cachedSingles = parseAndNamespace([typedInlineFrag1, typedInlineFrag2]);
131 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
132 |   t.is(actual, expected);
133 | });
134 | 
135 | test('merge a typed inline fragment when the target does not have one', t => {
136 |   const expectedRaw = `
137 |   mutation {
138 |     createPost(newPost: {_id: "129", author: "a123", content: "X", title:"Y", category:"hot stuff"}) {
139 |       post {
140 |         _id
141 |         ... on PostType {
142 |           title
143 |         }
144 |       }
145 |     }
146 |   }`;
147 |   const expected = parseSortPrint(expectedRaw);
148 |   const cachedSingles = parseAndNamespace([typedInlineFrag1, createPostWithPostId]);
149 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
150 |   t.is(actual, expected);
151 | });
152 | 
153 | test('merge a new variableDefinition', t => {
154 |   const expectedRaw = `
155 |   mutation($postId: String!, $content: String!, $_id: String!) {
156 |     createComment(postId: $postId, content: $content, _id: $_id) {
157 |       _id,
158 |     }
159 |   }`;
160 |   const expected = parseSortPrint(expectedRaw);
161 |   const cachedSingles = parseAndNamespace([createCommentWithId2, createCommentWithId]);
162 |   const actual = parseSortPrint(mergeMutations(cachedSingles));
163 |   t.is(actual, expected);
164 | });
165 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/namespaceMutation-data.js:
--------------------------------------------------------------------------------
 1 | export const createCommentWithId = `
 2 |   mutation {
 3 |     createComment(postId: $postId, content: "foo") {
 4 |       _id,
 5 |     }
 6 |   }`;
 7 | 
 8 | export const createCommentDifferentArg = `
 9 |   mutation {
10 |     createComment(postId: $postIdz) {
11 |       _id,
12 |     }
13 |   }`;
14 | 
15 | export const badArg = `
16 |   mutation {
17 |     createComment(postIdz: $postIdz) {
18 |       _id,
19 |     }
20 |   }`;
21 | 
22 | export const createMembers = `mutation {
23 |     createMembers(members: $newMembers) {
24 |       __typename
25 |     }
26 |   }`;
27 | 
28 | export const mixHardSoftArgs = `
29 |   mutation {
30 |     createPost(newPost: {_id: $postIdz}) {
31 |       _id,
32 |     }
33 |   }`;
34 | 
35 | export const nestedFragmentSpreads = `
36 | mutation {
37 |   createPost(newPost: {_id: "129"}) {
38 |     post {
39 |       ... {
40 |         ...spreadLevel1
41 |       }
42 |     }
43 |   }
44 | }
45 | fragment spreadLevel1 on PostType {
46 |   	... {
47 |       ...spreadLevel2
48 |     }
49 | }
50 | fragment spreadLevel2 on PostType {
51 |   createdAt
52 | }`;
53 | 
54 | export const postSpanishTitle = `
55 |   mutation {
56 |     createPost(newPost: {_id: "129"}) {
57 |       post {
58 |         title(language:"spanish")
59 |         englishTitle: title(language:"english")
60 |       }
61 |     }
62 |   }`;
63 | 
64 | export const postSpanishTitleVars = `
65 |   mutation {
66 |     createPost(newPost: {_id: $newPostId}) {
67 |       post {
68 |         title(language: $defaultLanguage),
69 |         englishTitle: title(language: $secondaryLanguage)
70 |       }
71 |     }
72 |   }`;
73 | 
74 | export const mixPostFieldArgs = `
75 |   mutation {
76 |     createPost(newPost: {_id: "123"}) {
77 |       post {
78 |         createdAt(dateOptions: {day: $day, month: true, year: $year})
79 |       }
80 |     }
81 |   }`;
82 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/namespaceMutation-tests.js:
--------------------------------------------------------------------------------
  1 | import 'babel-register';
  2 | import test from 'ava';
  3 | import clientSchema from '../../__tests__/clientSchema.json';
  4 | import namespaceMutation from '../namespaceMutation';
  5 | import {parseSortPrint, sortPrint} from '../../__tests__/parseSortPrint';
  6 | import {parse} from '../../utils';
  7 | 
  8 | import {
  9 |   createCommentWithId,
 10 |   createCommentDifferentArg,
 11 |   mixHardSoftArgs,
 12 |   createMembers,
 13 |   nestedFragmentSpreads,
 14 |   postSpanishTitle,
 15 |   postSpanishTitleVars,
 16 |   mixPostFieldArgs,
 17 |   badArg
 18 | } from './namespaceMutation-data';
 19 | 
 20 | /* variableDefinitions Tests */
 21 | test('creates simple variableDefinitions from mutation arguments, ignore hardcoded args', t => {
 22 |   const expectedRaw = `
 23 |   mutation($postId: String!) {
 24 |     createComment(postId: $postId, content: "foo") {
 25 |       _id,
 26 |     }
 27 |   }`;
 28 |   const expected = parseSortPrint(expectedRaw);
 29 |   const mutationAST = parse(createCommentWithId);
 30 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
 31 |   const actual = sortPrint(namespaceAST);
 32 |   t.is(actual, expected);
 33 | });
 34 | 
 35 | test('throws when trying to pass in a bogus argument', t => {
 36 |   const mutationAST = parse(badArg);
 37 |   t.throws(() => namespaceMutation(mutationAST, 'component1', {}, clientSchema));
 38 | });
 39 | 
 40 | test('creates variableDefinitions with different names', t => {
 41 |   const expectedRaw = `
 42 |   mutation($postIdz: String!) {
 43 |     createComment(postId: $postIdz) {
 44 |       _id,
 45 |     }
 46 |   }`;
 47 |   const expected = parseSortPrint(expectedRaw);
 48 |   const mutationAST = parse(createCommentDifferentArg);
 49 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
 50 |   const actual = sortPrint(namespaceAST);
 51 |   t.is(actual, expected);
 52 | });
 53 | 
 54 | test('allows for variables inside hardcoded object args', t => {
 55 |   const expectedRaw = `
 56 |   mutation($postIdz: String!) {
 57 |     createPost(newPost: {_id: $postIdz}) {
 58 |       _id,
 59 |     }
 60 |   }`;
 61 |   const expected = parseSortPrint(expectedRaw);
 62 |   const mutationAST = parse(mixHardSoftArgs);
 63 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
 64 |   const actual = sortPrint(namespaceAST);
 65 |   t.is(actual, expected);
 66 | });
 67 | 
 68 | test('creates required list variableDefinitions from mutation arguments', t => {
 69 |   const expectedRaw = `mutation ($newMembers: [NewMember!]!) {
 70 |     createMembers(members: $newMembers) {
 71 |       __typename
 72 |     }
 73 |   }`;
 74 |   const expected = parseSortPrint(expectedRaw);
 75 |   const mutationAST = parse(createMembers);
 76 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
 77 |   const actual = sortPrint(namespaceAST);
 78 |   t.is(actual, expected);
 79 | });
 80 | 
 81 | /* Inlining Tests */
 82 | test('turns all fragment spreads to inline fragments', t => {
 83 |   const expectedRaw = `
 84 |   mutation {
 85 |     createPost(newPost: {_id: "129"}) {
 86 |       post {
 87 |         ... on PostType {
 88 |           ... on PostType {
 89 |             createdAt
 90 |           }
 91 |         }
 92 |       }
 93 |     }
 94 |   }`;
 95 |   const expected = parseSortPrint(expectedRaw);
 96 |   const mutationAST = parse(nestedFragmentSpreads);
 97 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
 98 |   const actual = sortPrint(namespaceAST);
 99 |   t.is(actual, expected);
100 | });
101 | 
102 | /* Namespacing Tests */
103 | test('aliases all fields with arguments', t => {
104 |   const expectedRaw = `
105 |   mutation {
106 |     createPost(newPost: {_id: "129"}) {
107 |       post {
108 |         CASHAY_component1_title: title(language:"spanish"),
109 |         CASHAY_component1_englishTitle: title(language:"english")
110 |       }
111 |     }
112 |   }`;
113 |   const expected = parseSortPrint(expectedRaw);
114 |   const mutationAST = parse(postSpanishTitle);
115 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
116 |   const actual = sortPrint(namespaceAST);
117 |   t.is(actual, expected);
118 | });
119 | 
120 | test('augments the variables object with required fields from state', t => {
121 |   const expectedRaw = `
122 |   mutation ($newPostId: String!, $CASHAY_component1_defaultLanguage: String, $CASHAY_component1_secondaryLanguage: String) {
123 |     createPost(newPost: {_id: $newPostId}) {
124 |       post {
125 |         CASHAY_component1_title: title(language: $defaultLanguage),
126 |         CASHAY_component1_englishTitle: title(language: $secondaryLanguage)
127 |       }
128 |     }
129 |   }`;
130 |   const expected = parseSortPrint(expectedRaw);
131 |   const mutationAST = parse(postSpanishTitleVars);
132 |   const stateVars = {
133 |     defaultLanguage: 'spanish',
134 |     secondaryLanguage: 'english'
135 |   };
136 |   const {namespaceAST, variableEnhancers} = namespaceMutation(mutationAST, 'component1', stateVars, clientSchema);
137 |   const actual = sortPrint(namespaceAST);
138 |   const actualVariables = variableEnhancers.reduce((reduction, enhancer) => enhancer(reduction), {});
139 |   const expectedVariables = {
140 |     CASHAY_component1_defaultLanguage: 'spanish',
141 |     CASHAY_component1_secondaryLanguage: 'english'
142 |   };
143 |   t.is(actual, expected);
144 |   t.deepEqual(actualVariables, expectedVariables);
145 | });
146 | 
147 | test('allows for field variables inside hardcoded object args', t => {
148 |   const expectedRaw = `
149 |   mutation($CASHAY_component1_day: Boolean, $CASHAY_component1_year: Boolean) {
150 |     createPost(newPost: {_id: "123"}) {
151 |       post {
152 |         CASHAY_component1_createdAt: createdAt(dateOptions: {day: $day, month: true, year: $year})
153 |       }
154 |     }
155 |   }`;
156 |   const expected = parseSortPrint(expectedRaw);
157 |   const mutationAST = parse(mixPostFieldArgs);
158 |   const {namespaceAST} = namespaceMutation(mutationAST, 'component1', {}, clientSchema);
159 |   const actual = sortPrint(namespaceAST);
160 |   t.is(actual, expected);
161 | });
162 | 


--------------------------------------------------------------------------------
/src/mutate/__tests__/removeNamespacing-tests.js:
--------------------------------------------------------------------------------
 1 | import 'babel-register';
 2 | import test from 'ava';
 3 | import removeNamespacing from '../removeNamespacing';
 4 | 
 5 | /* variableDefinitions Tests */
 6 | test('removes 2 irrelevant namespaces: 1 prefixed, 1 not', t => {
 7 |   const input = {
 8 |     "data": {
 9 |       "createPost": {
10 |         "post": {
11 |           "CASHAY_component1_title": "FOOIE EN ESPANOL!",
12 |           "CASHAY_component1_reverseTitle": "EIOOF",
13 |           "title": "FOOIE"
14 |         }
15 |       }
16 |     }
17 |   };
18 |   const expected = {
19 |     "data": {
20 |       "createPost": {
21 |         "post": {
22 |           "title": "FOOIE EN ESPANOL!",
23 |           "reverseTitle": "EIOOF"
24 |         }
25 |       }
26 |     }
27 |   };
28 |   const actual = removeNamespacing(input, 'component1');
29 |   t.deepEqual(actual, expected);
30 | });
31 | 


--------------------------------------------------------------------------------
/src/mutate/createBasicMutation.js:
--------------------------------------------------------------------------------
 1 | import {print} from 'graphql/language/printer';
 2 | import makeArgsFromVars from './makeArgsFromVars';
 3 | import {MutationShell} from '../helperClasses';
 4 | import createVariableDefinitions from '../createVariableDefinitions';
 5 | 
 6 | export default function createBasicMutation(mutationName, schema, variables) {
 7 |   const mutationFieldSchema = schema.mutationSchema.fields[mutationName];
 8 |   if (!mutationFieldSchema) {
 9 |     throw new Error(`${mutationName} not found in your mutation schema! Did you include it?`)
10 |   }
11 |   const mutationArgs = makeArgsFromVars(mutationFieldSchema, variables);
12 |   const context = {schema, initialVariableDefinitions: []};
13 |   const {variableDefinitions} = createVariableDefinitions(mutationArgs, mutationFieldSchema, false, context);
14 |   const mutationAST = new MutationShell(mutationName, mutationArgs, variableDefinitions, true);
15 |   return print(mutationAST);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/mutate/createMutationFromQuery.js:
--------------------------------------------------------------------------------
 1 | import {ensureRootType, clone} from '../utils';
 2 | import {MutationShell, Field} from '../helperClasses';
 3 | import {mergeSelections} from './mergeMutations';
 4 | import {TypeKind} from 'graphql/type/introspection';
 5 | import findTypeInQuery from './findTypeInQuery';
 6 | import makeArgsFromVars from './makeArgsFromVars';
 7 | 
 8 | const {SCALAR} = TypeKind;
 9 | 
10 | 
11 | export default function createMutationFromQuery(operation, mutationName, mutationVariables = {}, schema) {
12 |   const mutationFieldSchema = schema.mutationSchema.fields[mutationName];
13 |   const mutationResponseType = ensureRootType(mutationFieldSchema.type);
14 |   const mutationResponseSchema = schema.types[mutationResponseType.name];
15 | 
16 |   // generating a mutation string requires guessing at what field arguments to pass in
17 |   // if the variables object includes something with the same name as the arg name, that's probably a fair heuristic
18 |   const mutationArgs = makeArgsFromVars(mutationFieldSchema, mutationVariables);
19 |   const mutationAST = new MutationShell(mutationName, mutationArgs);
20 | 
21 |   // Assume the mutationResponseSchema is a single type (opposed to a payload full of many types)
22 |   const simpleSelections = trySimplePayload(mutationResponseSchema.name, operation, schema);
23 |   if (simpleSelections) {
24 |     mutationAST.definitions[0].selectionSet.selections[0].selectionSet.selections = simpleSelections;
25 |     return mutationAST;
26 |   }
27 | 
28 |   // guess it's full of many types!
29 |   return tryComplexPayload(mutationAST, operation, mutationResponseSchema, schema);
30 | };
31 | 
32 | const trySimplePayload = (typeName, operation, schema) => {
33 |   const selectionsInQuery = findTypeInQuery(typeName, operation, schema);
34 |   if (selectionsInQuery.length) {
35 |     const allSelections = flattenFoundSelections(selectionsInQuery);
36 |     // TODO for simple payloads, I think pushing a clone of allSelections is good enough
37 |     return createMergedCopy(allSelections);
38 |   }
39 | };
40 | 
41 | const tryComplexPayload = (mutationAST, operation, mutationResponseSchema, schema) => {
42 |   let atLeastOne = false;
43 | 
44 |   // the payload itself isn't used, since it's just a shell for the many fields inside
45 |   // technically, this could (should?) be recursive, but cashay enforces best practices
46 |   // and putting an abstract inside an abstract is wrong
47 |   const payloadFieldKeys = Object.keys(mutationResponseSchema.fields);
48 | 
49 |   for (let i = 0; i < payloadFieldKeys.length; i++) {
50 |     const payloadFieldKey = payloadFieldKeys[i];
51 |     const payloadField = mutationResponseSchema.fields[payloadFieldKey];
52 |     const rootPayloadFieldType = ensureRootType(payloadField.type);
53 | 
54 |     // For scalars, make sure the names match (don't want a million strings in the mutation request)
55 |     const matchName = rootPayloadFieldType.kind === SCALAR && payloadField.name;
56 |     const selectionsInQuery = findTypeInQuery(rootPayloadFieldType.name, operation, schema, matchName);
57 |     if (selectionsInQuery.length) {
58 |       atLeastOne = true;
59 |       const allSelections = matchName ? selectionsInQuery : flattenFoundSelections(selectionsInQuery);
60 |       let mutationField;
61 |       if (matchName) {
62 |         mutationField = new Field({name: matchName});
63 |       } else {
64 |         const newSelections = createMergedCopy(allSelections);
65 |         // make a payload field into a mutation field
66 |         mutationField = new Field({name: payloadFieldKey, selections: newSelections});
67 |       }
68 |       mutationAST.definitions[0].selectionSet.selections[0].selectionSet.selections.push(mutationField);
69 |     }
70 |   }
71 |   if (!atLeastOne) {
72 |     throw new Error(`Could not generate a mutation from ${operation.selectionSet.selections[0].name.value}. 
73 |     Verify that ${mutationResponseSchema.name} is correct and the schema is updated. 
74 |     If it includes scalars, make sure those are aliased in the query.`)
75 |   }
76 |   return mutationAST;
77 | };
78 | 
79 | const flattenFoundSelections = selectionsInQuery => {
80 |   const allSelections = [];
81 |   for (let i = 0; i < selectionsInQuery.length; i++) {
82 |     const {selections} = selectionsInQuery[i].selectionSet;
83 |     allSelections.push(...selections);
84 |   }
85 |   return allSelections;
86 | };
87 | 
88 | const createMergedCopy = allSelections => {
89 |   const firstSelection = allSelections.pop();
90 |   if (!firstSelection) return;
91 |   const targetSelections = [clone(firstSelection)];
92 |   mergeSelections(targetSelections, allSelections);
93 |   return targetSelections;
94 | };
95 | 


--------------------------------------------------------------------------------
/src/mutate/findTypeInQuery.js:
--------------------------------------------------------------------------------
 1 | import {INLINE_FRAGMENT} from 'graphql/language/kinds';
 2 | import {ensureRootType, getVariableValue, parseCachedType} from '../utils'
 3 | /**
 4 |  * Traverses a query AST operation looking for a specific type (for objects) or name (for scalars)
 5 |  * Uses a BFS since return values are likely high up the tree & scalars can break as soon as a matching name is found
 6 |  *
 7 |  * @param {String} typeName the type of GraphQL object to look for
 8 |  * @param {Object} operation the request AST's definition to traverse
 9 |  * @param {Object} schema the cashay client schema
10 |  * @param {String} [matchName] if provided, it will match by typeName AND matchName (used for scalars)
11 |  *
12 |  * @returns {Array} a bag full of selections whose children will be added to the mutation response
13 |  */
14 | export default function findTypeInQuery(typeName, operation, schema, matchName) {
15 |   const bag = [];
16 |   const queue = [];
17 |   let next = {
18 |     operation,
19 |     typeSchema: schema.querySchema
20 |   };
21 |   while (next) {
22 |     const {operation, typeSchema} = next;
23 |     if (operation.selectionSet) {
24 |       const {selections} = operation.selectionSet;
25 |       for (let i = 0; i < selections.length; i++) {
26 |         const selection = selections[i];
27 |         let subSchema;
28 |         if (selection.kind === INLINE_FRAGMENT) {
29 |           subSchema = typeSchema;
30 |         } else {
31 |           const selectionName = selection.name.value;
32 |           const cachedDirective = selection.directives.find(d => d.name.value === 'cached');
33 |           if (cachedDirective) {
34 |             const typeArg = cachedDirective.arguments.find(arg => arg.name.value === 'type');
35 |             // this will throw if type isn't static
36 |             const typeName = getVariableValue(typeArg);
37 |             const {type} = parseCachedType(typeName);
38 |             subSchema = schema.types[type]
39 |           } else {
40 |             const fieldSchema = typeSchema.fields[selectionName];
41 |             const rootFieldType = ensureRootType(fieldSchema.type);
42 |             subSchema = schema.types[rootFieldType.name];
43 |           }
44 |           if (subSchema.name === typeName) {
45 |             if (matchName) {
46 |               const fieldNameOrAlias = selection.alias && selection.alias.value || selectionName;
47 |               if (matchName === fieldNameOrAlias) {
48 |                 bag[0] = selection;
49 |                 return bag;
50 |               }
51 |             } else {
52 |               bag.push(selection);
53 |             }
54 |           }
55 |         }
56 |         queue.push({
57 |           operation: selection,
58 |           typeSchema: subSchema
59 |         })
60 |       }
61 |     }
62 |     next = queue.shift();
63 |   }
64 |   return bag;
65 | };
66 | 


--------------------------------------------------------------------------------
/src/mutate/hasMatchingVariables.js:
--------------------------------------------------------------------------------
 1 | export default function hasMatchingVariables(variables, matchingSet) {
 2 |   const varKeys = Object.keys(variables);
 3 |   if (varKeys.length !== matchingSet.size) return false;
 4 |   for (let i = 0; i < varKeys.length; i++) {
 5 |     const varKey = varKeys[i];
 6 |     if (!matchingSet.has(varKey)) return false;
 7 |   }
 8 |   return true;
 9 | };
10 | 


--------------------------------------------------------------------------------
/src/mutate/isMutationResponseScalar.js:
--------------------------------------------------------------------------------
 1 | import {ensureRootType} from '../utils';
 2 | import {TypeKind} from 'graphql/type/introspection';
 3 | 
 4 | const {SCALAR} = TypeKind;
 5 | 
 6 | export default function isMutationResponseScalar(schema, mutationName) {
 7 |   const mutationFieldSchema = schema.mutationSchema.fields[mutationName];
 8 |   const mutationResponseType = ensureRootType(mutationFieldSchema.type);
 9 |   const mutationResponseSchema = schema.types[mutationResponseType.name];
10 |   return mutationResponseSchema.kind === SCALAR;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/mutate/makeArgsFromVars.js:
--------------------------------------------------------------------------------
 1 | import {RequestArgument} from '../helperClasses';
 2 | import {VARIABLE} from 'graphql/language/kinds';
 3 | 
 4 | export default function makeArgsFromVars(mutationFieldSchema, variables) {
 5 |   const mutationArgs = [];
 6 |   const argKeys = Object.keys(mutationFieldSchema.args);
 7 |   for (let i = 0; i < argKeys.length; i++) {
 8 |     const argKey = argKeys[i];
 9 |     const schemaArg = mutationFieldSchema.args[argKey];
10 |     if (variables.hasOwnProperty(schemaArg.name)) {
11 |       const newArg = new RequestArgument(schemaArg.name, VARIABLE, schemaArg.name);
12 |       mutationArgs.push(newArg);
13 |     }
14 |   }
15 |   return mutationArgs;
16 | };
17 | 


--------------------------------------------------------------------------------
/src/mutate/makeFriendlyStore.js:
--------------------------------------------------------------------------------
 1 | import findTypeInQuery from './findTypeInQuery';
 2 | import getFieldState from '../normalize/getFieldState';
 3 | import {isObject} from '../utils';
 4 | 
 5 | export default function makeFriendlyStore(rawState, typeName, context) {
 6 |   const {operation, schema} = context;
 7 |   const recurseRawStore = (subStore, typeToFind) => {
 8 |     const friendlyStore = {};
 9 |     const typeKeys = Object.keys(subStore);
10 |     const fieldSchema = schema.types[typeToFind];
11 |     for (let i = 0; i < typeKeys.length; i++) {
12 |       const typeKey = typeKeys[i];
13 |       const rawFieldState = subStore[typeKey];
14 |       const selection = findTypeInQuery(typeToFind, operation, schema);
15 |       const fieldState = getFieldState(rawFieldState, fieldSchema, selection, context)
16 |       if (isObject(fieldState) && schema.types[typeKey]) {
17 |         fieldState[typeKey] = recurseRawStore(rawFieldState, typeKey);
18 |       }
19 |       friendlyStore[typeKey] = fieldState;
20 |     }
21 |     return friendlyStore;
22 |   };
23 |   recurseRawStore(rawState, typeName);
24 | };
25 | 


--------------------------------------------------------------------------------
/src/mutate/mergeMutations.js:
--------------------------------------------------------------------------------
  1 | import {
  2 |   OBJECT,
  3 |   INLINE_FRAGMENT
  4 | } from 'graphql/language/kinds';
  5 | import {clone} from '../utils';
  6 | import {print} from 'graphql/language/printer';
  7 | 
  8 | export default function mergeMutations(cachedSingles) {
  9 |   const firstSingle = cachedSingles.pop();
 10 | 
 11 |   // deep copy to create the base AST (slow, but faster than a parse!)
 12 |   const mergedAST = clone(firstSingle);
 13 |   const mainOperation = mergedAST.definitions[0];
 14 |   const mainMutation = mainOperation.selectionSet.selections[0];
 15 |   
 16 |   // now add the new ASTs one-by-one
 17 |   for (let i = 0; i < cachedSingles.length; i++) {
 18 |     const single = cachedSingles[i];
 19 |     const nextOperation = single.definitions[0];
 20 |     const nextMutation = nextOperation.selectionSet.selections[0];
 21 |     mergeVariableDefinitions(mainOperation.variableDefinitions, nextOperation.variableDefinitions);
 22 |     mergeNewAST(mainMutation, nextMutation);
 23 |   }
 24 |   return print(mergedAST);
 25 | };
 26 | 
 27 | const mergeVariableDefinitions = (mainVarDefs, nextVarDefs) => {
 28 |   for (let varDef of nextVarDefs) {
 29 |     const nextName = varDef.variable.name.value;
 30 |     const varDefInMain = mainVarDefs.find(def => def.variable.name.value === nextName);
 31 |     if (!varDefInMain) {
 32 |       mainVarDefs.push(varDef);
 33 |     }
 34 |   }
 35 | };
 36 | 
 37 | const mergeNewAST = (target, src) => {
 38 |   if (target.name.value !== src.name.value) {
 39 |     throw new Error(`Cannot merge two different mutations: 
 40 |     ${target.name.value} and ${src.name.value}.
 41 |     Did you include the wrong componentId in the mutation call?
 42 |     Make sure each mutation operation only calls a single mutation 
 43 |     and that customMutations are correct.`)
 44 |   }
 45 |   mergeMutationArgs(target.arguments, src.arguments);
 46 |   mergeSelections(target.selectionSet.selections, src.selectionSet.selections);
 47 | };
 48 | 
 49 | /**
 50 |  * Mutates the targetSelections by adding srcSelections & excluding the duplicates
 51 |  */
 52 | export const mergeSelections = (targetSelections, srcSelections) => {
 53 |   for (let i = 0; i < srcSelections.length; i++) {
 54 |     const selection = srcSelections[i];
 55 |     mergeSingleProp(targetSelections, selection)
 56 |   }
 57 | };
 58 | 
 59 | const mergeSingleProp = (targetSelections, srcProp) => {
 60 |   if (srcProp.kind === INLINE_FRAGMENT) {
 61 |     // typeCondition is guaranteed to exist thanks to namespaceMutation
 62 |     const srcTypeCondition = srcProp.typeCondition.name.value;
 63 |     let targetFragment = targetSelections.find(field => field.kind === INLINE_FRAGMENT && field.typeCondition.name.value === srcTypeCondition);
 64 |     if (!targetFragment) {
 65 |       // by pushing a clone, we don't have to clone the srcProp beforehand, making for the smallest amount of cloning possible
 66 |       targetSelections.push(clone(srcProp));
 67 |     } else {
 68 |       mergeSelections(targetFragment.selectionSet.selections, srcProp.selectionSet.selections);
 69 |     }
 70 |     return;
 71 |   }
 72 |   if (srcProp.alias) {
 73 |     // alias infers args, which means we can't join anything
 74 |     targetSelections.push(clone(srcProp));
 75 |   } else {
 76 |     const propName = srcProp.name.value;
 77 |     const propInTarget = targetSelections.find(selection => !selection.alias && selection.name.value === propName);
 78 |     if (propInTarget) {
 79 |       if (propInTarget.selectionSet) {
 80 |         mergeSelections(propInTarget.selectionSet.selections, srcProp.selectionSet.selections)
 81 |       }
 82 |     } else {
 83 |       targetSelections.push(clone(srcProp));
 84 |     }
 85 |   }
 86 | };
 87 | 
 88 | /**
 89 |  * For the mutation itself, try to merge args
 90 |  * but for children of the mutation, don't
 91 |  */
 92 | const mergeMutationArgs = (targetArgs, srcArgs) => {
 93 |   for (let i = 0; i < srcArgs.length; i++) {
 94 |     const srcArg = srcArgs[i];
 95 |     const targetArg = targetArgs.find(arg => arg.name.value === srcArg.name.value);
 96 |     if (targetArg) {
 97 |       if (targetArg.value.kind === OBJECT) {
 98 |         if (srcArg.value.kind === OBJECT) {
 99 |           // handle input objects
100 |           mergeMutationArgs(targetArg.value.fields, srcArg.value.fields);
101 |         } else {
102 |           throw new Error(`Conflicting kind for argument: ${targetArg.name.value}`)
103 |         }
104 |       } else if (targetArg.value.value !== srcArg.value.value) {
105 |         throw new Error(`Conflicting values for argument: ${targetArg.name.value}`)
106 |       }
107 |     } else {
108 |       targetArgs.push(clone(srcArg));
109 |     }
110 |   }
111 | };
112 | 


--------------------------------------------------------------------------------
/src/mutate/namespaceMutation.js:
--------------------------------------------------------------------------------
 1 | import {ensureRootType} from '../utils';
 2 | import {FRAGMENT_SPREAD, INLINE_FRAGMENT} from 'graphql/language/kinds';
 3 | import {clone, convertFragmentToInline, teardownDocumentAST, makeNamespaceString} from '../utils';
 4 | import {Name} from '../helperClasses';
 5 | import createVariableDefinitions from '../createVariableDefinitions';
 6 | 
 7 | export default function namespaceMutation(mutationAST, op, opStateVars = {}, schema) {
 8 |   const {operation, fragments} = teardownDocumentAST(mutationAST.definitions);
 9 |   const mainMutation = operation.selectionSet.selections[0];
10 |   const fieldSchema = schema.mutationSchema.fields[mainMutation.name.value];
11 |   const startingContext = {op, opStateVars, schema, fragments, initialVariableDefinitions: []};
12 |   // query-level fields are joined, not namespaced, so we have to treat them differently
13 |   const {variableDefinitions: initialVariableDefinitions, variableEnhancers} =
14 |     createVariableDefinitions(mainMutation.arguments, fieldSchema, false, startingContext);
15 |   const context = {...startingContext, fragments, initialVariableDefinitions};
16 |   operation.variableDefinitions = initialVariableDefinitions;
17 |   const rootSchemaType = ensureRootType(fieldSchema.type);
18 |   const subSchema = schema.types[rootSchemaType.name];
19 |   if (mainMutation.selectionSet) {
20 |     // MUTATES SELECTIONS, CONTEXT VARIABLE DEFS, AND VARIABLE ENHANCERS. AND IT'S REALLY HARD TO MAKE IT FUNCTIONAL & PERFORMANT
21 |     namespaceAndInlineFrags(mainMutation.selectionSet.selections, subSchema, variableEnhancers, context);
22 |   }
23 | 
24 |   // just take the operation & leave behind the fragment spreads, since we inlined them
25 |   mutationAST.definitions = [operation];
26 |   return {namespaceAST: mutationAST, variableEnhancers}
27 | };
28 | 
29 | const namespaceAndInlineFrags = (fieldSelections, typeSchema, variableEnhancers, context) => {
30 |   for (let i = 0; i < fieldSelections.length; i++) {
31 |     let selection = fieldSelections[i];
32 |     if (selection.kind === FRAGMENT_SPREAD) {
33 |       const fragment = clone(context.fragments[selection.name.value]);
34 |       fieldSelections[i] = selection = convertFragmentToInline(fragment);
35 |     }
36 |     if (selection.kind === INLINE_FRAGMENT) {
37 |       // if the fragment is unnecessary, remove it
38 |       if (selection.typeCondition === null) {
39 |         fieldSelections.push(...selection.selectionSet.selections);
40 |         // since we're pushing to the looped array, going in reverse won't save us from not having to change i
41 |         fieldSelections.splice(i--, 1);
42 |       } else {
43 |         namespaceAndInlineFrags(selection.selectionSet.selections, typeSchema, variableEnhancers, context);
44 |       }
45 |       continue;
46 |     }
47 |     const selectionName = selection.name.value;
48 |     if (selectionName.startsWith('__')) continue;
49 |     const fieldSchema = typeSchema.fields[selectionName];
50 |     if (selection.arguments && selection.arguments.length) {
51 |       const aliasOrFieldName = selection.alias && selection.alias.value || selection.name.value;
52 |       const namespaceAlias = makeNamespaceString(context.op, aliasOrFieldName);
53 |       selection.alias = new Name(namespaceAlias);
54 |       const mutations = createVariableDefinitions(selection.arguments, fieldSchema, true, context);
55 |       context.initialVariableDefinitions.push(...mutations.variableDefinitions);
56 |       variableEnhancers.push(...mutations.variableEnhancers);
57 |     } else {
58 |       // guarantee that props without args are also without aliases
59 |       // that way, we can share fields across mutations & not make the server repeat the same action twice
60 |       selection.alias = null;
61 |     }
62 |     if (selection.selectionSet) {
63 |       const fieldType = ensureRootType(fieldSchema.type);
64 |       const subSchema = context.schema.types[fieldType.name];
65 |       namespaceAndInlineFrags(selection.selectionSet.selections, subSchema, variableEnhancers, context);
66 |     }
67 |   }
68 | };
69 | 


--------------------------------------------------------------------------------
/src/mutate/removeNamespacing.js:
--------------------------------------------------------------------------------
 1 | import {isObject, CASHAY, DELIMITER} from '../utils';
 2 | 
 3 | export default function removeNamespacing(dataObj, componentId) {
 4 |   if (!isObject(dataObj)) {
 5 |     return dataObj;
 6 |   }
 7 |   const normalizedData = removeNamespacedFields(dataObj, componentId);
 8 |   const queryKeys = Object.keys(normalizedData);
 9 |   for (let i = 0; i < queryKeys.length; i++) {
10 |     const queryKey = queryKeys[i];
11 |     const normalizedProp = normalizedData[queryKey];
12 |     if (isObject(normalizedProp)) {
13 |       if (Array.isArray(normalizedProp)) {
14 |         normalizedData[queryKey] = normalizedProp.map(prop => removeNamespacing(prop, componentId));
15 |       } else {
16 |         normalizedData[queryKey] = removeNamespacing(normalizedProp, componentId)
17 |       }
18 |     }
19 |   }
20 |   return normalizedData;
21 | }
22 | 
23 | const removeNamespacedFields = (dataObj, componentId) => {
24 |   const normalizedData = {...dataObj};
25 |   let queryKeys = Object.keys(normalizedData);
26 |   for (let i = 0; i < queryKeys.length; i++) {
27 |     const queryKey = queryKeys[i];
28 |     const [prefix, fieldComponentId, fieldNameOrAlias] = queryKey.split(DELIMITER);
29 |     if (prefix === CASHAY) {
30 |       if (fieldComponentId === componentId) {
31 |         normalizedData[fieldNameOrAlias] = normalizedData[queryKey];
32 |       }
33 |       delete normalizedData[queryKey];
34 |     }
35 |   }
36 |   return normalizedData;
37 | };
38 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/data-pagination-back.js:
--------------------------------------------------------------------------------
  1 | export const back3Query = `
  2 | query {
  3 |   getRecentPosts(last:3) {
  4 |     _id,
  5 |     cursor
  6 |   }
  7 | }`;
  8 | 
  9 | export const back3Response = {
 10 |   "data": {
 11 |     "getRecentPosts": [
 12 |       {
 13 |         "_id": "p125",
 14 |         "cursor": "1433333333333chikachikow"
 15 |       },
 16 |       {
 17 |         "_id": "p124",
 18 |         "cursor": "1422222222222chikachikow"
 19 |       },
 20 |       {
 21 |         "_id": "p123",
 22 |         "cursor": "1411111111111chikachikow"
 23 |       }
 24 |     ]
 25 |   }
 26 | }
 27 | 
 28 | export const back3Store = {
 29 |   "entities": {
 30 |     "PostType": {
 31 |       "p125": {
 32 |         "_id": "p125",
 33 |         "cursor": "1433333333333chikachikow"
 34 |       },
 35 |       "p124": {
 36 |         "_id": "p124",
 37 |         "cursor": "1422222222222chikachikow"
 38 |       },
 39 |       "p123": {
 40 |         "_id": "p123",
 41 |         "cursor": "1411111111111chikachikow"
 42 |       }
 43 |     }
 44 |   },
 45 |   "result": {
 46 |     "getRecentPosts": {
 47 |       "back": [
 48 |         "PostType::p125",
 49 |         "PostType::p124",
 50 |         "PostType::p123"
 51 |       ]
 52 |     }
 53 |   }
 54 | };
 55 | 
 56 | export const back2After3Query = `
 57 | query {
 58 |   getRecentPosts(last:2, beforeCursor: "1433333333333chikachikow") {
 59 |     _id,
 60 |     cursor
 61 |   }
 62 | }`;
 63 | 
 64 | export const back1After3Response = {
 65 |   "data": {
 66 |     "getRecentPosts": [
 67 |       {
 68 |         "_id": "p126",
 69 |         "cursor": "1444444444444chikachikow"
 70 |       }
 71 |     ]
 72 |   }
 73 | }
 74 | 
 75 | export const back2After3StoreFn = () => {
 76 |   const base = {
 77 |     "entities": {
 78 |       "PostType": {
 79 |         "p126": {
 80 |           "_id": "p126",
 81 |           "cursor": "1444444444444chikachikow"
 82 |         }
 83 |       }
 84 |     },
 85 |     "result": {
 86 |       "getRecentPosts": {
 87 |         "back": [
 88 |           "PostType::p126"
 89 |         ]
 90 |       }
 91 |     }
 92 |   }
 93 |   base.result.getRecentPosts.back.BOF = true;
 94 |   return base;
 95 | };
 96 | 
 97 | export const back4 = `
 98 | query {
 99 |   getRecentPosts(last:4) {
100 |     _id,
101 |     cursor
102 |   }
103 | }`;
104 | 
105 | export const back1After3Store = {
106 |   "entities": {
107 |     "PostType": {
108 |       "p126": {
109 |         "_id": "p126",
110 |         "cursor": "1444444444444chikachikow"
111 |       }
112 |     }
113 |   },
114 |   "result": {
115 |     "getRecentPosts": {
116 |       "back": [
117 |         "PostType::p126"
118 |       ]
119 |     }
120 |   }
121 | };
122 | 
123 | export const back1After4Query = `
124 | query {
125 |   getRecentPosts(last:1, beforeCursor: "1444444444444chikachikow") {
126 |     _id,
127 |     cursor
128 |   }
129 | }`;
130 | 
131 | export const back1After4Response = {
132 |   "data": {
133 |     "getRecentPosts": []
134 |   }
135 | };
136 | 
137 | export const back1After4StoreFn = () => {
138 |   const base = {
139 |     "entities": {},
140 |     "result": {
141 |       "getRecentPosts": {
142 |         "back": []
143 |       }
144 |     }
145 |   };
146 |   base.result.getRecentPosts.back.BOF = true;
147 |   return base;
148 | };
149 | 
150 | export const back4ResponseFn = (requestAmount) => {
151 |   const base = {
152 |     data: {
153 |       "getRecentPosts": [
154 |         {
155 |           "_id": "p126",
156 |           "cursor": "1444444444444chikachikow"
157 |         },
158 |         {
159 |           "_id": "p125",
160 |           "cursor": "1433333333333chikachikow"
161 |         },
162 |         {
163 |           "_id": "p124",
164 |           "cursor": "1422222222222chikachikow"
165 |         },
166 |         {
167 |           "_id": "p123",
168 |           "cursor": "1411111111111chikachikow"
169 |         }
170 |       ]
171 |     }
172 |   };
173 |   base.data.getRecentPosts.BOF = true;
174 |   base.data.getRecentPosts.EOF = true;
175 |   if (requestAmount !== undefined) {
176 |     base.data.getRecentPosts.count = requestAmount;
177 |   }
178 |   return base;
179 | };
180 | 
181 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/data-pagination-front.js:
--------------------------------------------------------------------------------
  1 | export const front3Query = `
  2 | query {
  3 |   getRecentPosts(first:3) {
  4 |     _id,
  5 |     cursor
  6 |   }
  7 | }`;
  8 | 
  9 | export const front4Query = `
 10 | query {
 11 |   getRecentPosts(first:4) {
 12 |     _id,
 13 |     cursor
 14 |   }
 15 | }`;
 16 | 
 17 | export const front3Response = {
 18 |   "data": {
 19 |     "getRecentPosts": [
 20 |       {
 21 |         "_id": "p126",
 22 |         "cursor": "1444444444444chikachikow"
 23 |       },
 24 |       {
 25 |         "_id": "p125",
 26 |         "cursor": "1433333333333chikachikow"
 27 |       },
 28 |       {
 29 |         "_id": "p124",
 30 |         "cursor": "1422222222222chikachikow"
 31 |       }
 32 |     ]
 33 |   }
 34 | };
 35 | 
 36 | export const front3LocalResponseFn = (requestAmount) => {
 37 |   const base = {
 38 | 
 39 |     "data": {
 40 |       "getRecentPosts": [
 41 |         {
 42 |           "_id": "p126",
 43 |           "cursor": "1444444444444chikachikow"
 44 |         },
 45 |         {
 46 |           "_id": "p125",
 47 |           "cursor": "1433333333333chikachikow"
 48 |         },
 49 |         {
 50 |           "_id": "p124",
 51 |           "cursor": "1422222222222chikachikow"
 52 |         }
 53 |       ]
 54 |     }
 55 |   };
 56 |   base.data.getRecentPosts.BOF = true;
 57 |   base.data.getRecentPosts.EOF = true;
 58 |   if (requestAmount !== undefined) {
 59 |     base.data.getRecentPosts.count = requestAmount;
 60 |   }
 61 |   return base;
 62 | };
 63 | 
 64 | export const front3Store = {
 65 |   "entities": {
 66 |     "PostType": {
 67 |       "p126": {
 68 |         "_id": "p126",
 69 |         "cursor": "1444444444444chikachikow"
 70 |       },
 71 |       "p125": {
 72 |         "_id": "p125",
 73 |         "cursor": "1433333333333chikachikow"
 74 |       },
 75 |       "p124": {
 76 |         "_id": "p124",
 77 |         "cursor": "1422222222222chikachikow"
 78 |       }
 79 |     }
 80 |   },
 81 |   "result": {
 82 |     "getRecentPosts": {
 83 |       front: [
 84 |         "PostType::p126",
 85 |         "PostType::p125",
 86 |         "PostType::p124"
 87 |       ]
 88 |     }
 89 |   }
 90 | };
 91 | 
 92 | export const front2After3Query = `
 93 | query {
 94 |   getRecentPosts(first:2, afterCursor: "1422222222222chikachikow") {
 95 |     _id,
 96 |     cursor
 97 |   }
 98 | }`;
 99 | 
100 | export const front1After3Response = {
101 |   "data": {
102 |     "getRecentPosts": [
103 |       {
104 |         "_id": "p123",
105 |         "cursor": "1411111111111chikachikow"
106 |       }
107 |     ]
108 |   }
109 | };
110 | 
111 | export const front2After3StoreFn = () => {
112 |   const base = {
113 |     "entities": {
114 |       "PostType": {
115 |         "p123": {
116 |           "_id": "p123",
117 |           "cursor": "1411111111111chikachikow"
118 |         }
119 |       }
120 |     },
121 |     "result": {
122 |       "getRecentPosts": {
123 |         "front": [
124 |           "PostType::p123"
125 |         ]
126 |       }
127 |     }
128 |   };
129 |   base.result.getRecentPosts.front.EOF = true;
130 |   // base.result.getRecentPosts.front.count = 1;
131 |   return base;
132 | };
133 | 
134 | export const front1After3Store = {
135 |   entities: {
136 |     PostType: {
137 |       p123: {
138 |         _id: "p123",
139 |         cursor: "1411111111111chikachikow"
140 |       }
141 |     }
142 |   },
143 |   result: {
144 |     getRecentPosts: {
145 |       front: [
146 |         "PostType::p123"
147 |       ]
148 |     }
149 |   }
150 | };
151 | 
152 | export const front1After4Query = `
153 | query {
154 |   getRecentPosts(first:1, afterCursor: "1411111111111chikachikow") {
155 |     _id,
156 |     cursor
157 |   }
158 | }`;
159 | 
160 | export const front1After4Response = {
161 |   "data": {
162 |     "getRecentPosts": []
163 |   }
164 | };
165 | 
166 | export const front1After4StoreFn = () => {
167 |   const base = {
168 |     "entities": {},
169 |     "result": {
170 |       "getRecentPosts": {
171 |         "front": []
172 |       }
173 |     }
174 |   };
175 |   base.result.getRecentPosts.front.EOF = true;
176 |   return base;
177 | };
178 | 
179 | export const back1After4StoreFn = () => {
180 |   const base = {
181 |     "entities": {},
182 |     "result": {
183 |       "getRecentPosts": {
184 |         "back": []
185 |       }
186 |     }
187 |   };
188 |   base.result.getRecentPosts.back.EOF = true;
189 |   return base;
190 | };
191 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/data-pagination.js:
--------------------------------------------------------------------------------
  1 | export const fullResponse = {
  2 |   "data": {
  3 |     "getRecentPosts": [
  4 |       {
  5 |         "_id": "p126",
  6 |         "cursor": "1444444444444chikachikow"
  7 |       },
  8 |       {
  9 |         "_id": "p125",
 10 |         "cursor": "1433333333333chikachikow"
 11 |       },
 12 |       {
 13 |         "_id": "p124",
 14 |         "cursor": "1422222222222chikachikow"
 15 |       },
 16 |       {
 17 |         "_id": "p123",
 18 |         "cursor": "1411111111111chikachikow"
 19 |       }
 20 |     ]
 21 |   }
 22 | };
 23 | 
 24 | export const fullPostStore = {
 25 |   "entities": {
 26 |     "PostType": {
 27 |       "p126": {
 28 |         "_id": "p126",
 29 |         "cursor": "1444444444444chikachikow"
 30 |       },
 31 |       "p125": {
 32 |         "_id": "p125",
 33 |         "cursor": "1433333333333chikachikow"
 34 |       },
 35 |       "p124": {
 36 |         "_id": "p124",
 37 |         "cursor": "1422222222222chikachikow"
 38 |       },
 39 |       "p123": {
 40 |         "_id": "p123",
 41 |         "cursor": "1411111111111chikachikow"
 42 |       }
 43 |     }
 44 |   },
 45 |   "result": {
 46 |     "getRecentPosts": {
 47 |       "full": [
 48 |         "PostType::p126",
 49 |         "PostType::p125",
 50 |         "PostType::p124",
 51 |         "PostType::p123"
 52 |       ]
 53 |     }
 54 |   }
 55 | };
 56 | 
 57 | export const front4PostStore = {
 58 |   "entities": {
 59 |     "PostType": {
 60 |       "p126": {
 61 |         "_id": "p126",
 62 |         "cursor": "1444444444444chikachikow"
 63 |       },
 64 |       "p125": {
 65 |         "_id": "p125",
 66 |         "cursor": "1433333333333chikachikow"
 67 |       },
 68 |       "p124": {
 69 |         "_id": "p124",
 70 |         "cursor": "1422222222222chikachikow"
 71 |       },
 72 |       "p123": {
 73 |         "_id": "p123",
 74 |         "cursor": "1411111111111chikachikow"
 75 |       }
 76 |     }
 77 |   },
 78 |   "result": {
 79 |     "getRecentPosts": {
 80 |       "front": [
 81 |         "PostType::p126",
 82 |         "PostType::p125",
 83 |         "PostType::p124",
 84 |         "PostType::p123"
 85 |       ]
 86 |     }
 87 |   }
 88 | };
 89 | 
 90 | export const back4PostStore = {
 91 |   "entities": {
 92 |     "PostType": {
 93 |       "p126": {
 94 |         "_id": "p126",
 95 |         "cursor": "1444444444444chikachikow"
 96 |       },
 97 |       "p125": {
 98 |         "_id": "p125",
 99 |         "cursor": "1433333333333chikachikow"
100 |       },
101 |       "p124": {
102 |         "_id": "p124",
103 |         "cursor": "1422222222222chikachikow"
104 |       },
105 |       "p123": {
106 |         "_id": "p123",
107 |         "cursor": "1411111111111chikachikow"
108 |       }
109 |     }
110 |   },
111 |   "result": {
112 |     "getRecentPosts": {
113 |       "back": [
114 |         "PostType::p126",
115 |         "PostType::p125",
116 |         "PostType::p124",
117 |         "PostType::p123"
118 |       ]
119 |     }
120 |   }
121 | };
122 | 
123 | export const back1Query = `
124 | query {
125 |   getRecentPosts(last:1) {
126 |     _id,
127 |     cursor
128 |   }
129 | }`;
130 | 
131 | export const back1Skip1Query = `
132 | query {
133 |   getRecentPosts(last:1, beforeCursor:"1411111111111chikachikow") {
134 |     _id,
135 |     cursor
136 |   }
137 | }`;
138 | 
139 | export const back1Store = {
140 |   entities: {
141 |     PostType: {
142 |       p123: {
143 |         _id: "p123",
144 |         cursor: "1411111111111chikachikow"
145 |       }
146 |     }
147 |   },
148 |   result: {
149 |     getRecentPosts: {
150 |       back: [
151 |         "PostType::p123"
152 |       ]
153 |     }
154 |   }
155 | };
156 | 
157 | export const back1StoreNoCursor = {
158 |   entities: {
159 |     PostType: {
160 |       p123: {
161 |         _id: "p123"
162 |       }
163 |     }
164 |   },
165 |   result: {
166 |     getRecentPosts: {
167 |       back: [
168 |         "PostType::p123"
169 |       ]
170 |     }
171 |   }
172 | };
173 | 
174 | export const back1NoCursorDenormalizedFn = () => {
175 |   const base = {
176 |     "getRecentPosts": [
177 |       {
178 |         "_id": "p123",
179 |         "cursor": null
180 |       }
181 |     ]
182 |   };
183 |   base.getRecentPosts.BOF = true;
184 |   base.getRecentPosts.EOF = true;
185 |   base.getRecentPosts.count = 1;
186 |   return base;
187 | };
188 | 
189 | export const front3Back1Store = {
190 |   "entities": {
191 |     "PostType": {
192 |       "p126": {
193 |         "_id": "p126",
194 |         "cursor": "1444444444444chikachikow"
195 |       },
196 |       "p125": {
197 |         "_id": "p125",
198 |         "cursor": "1433333333333chikachikow"
199 |       },
200 |       "p124": {
201 |         "_id": "p124",
202 |         "cursor": "1422222222222chikachikow"
203 |       },
204 |       "p123": {
205 |         "_id": "p123",
206 |         "cursor": "1411111111111chikachikow"
207 |       }
208 |     }
209 |   },
210 |   result: {
211 |     getRecentPosts: {
212 |       back: [
213 |         "PostType::p123"
214 |       ],
215 |       front: [
216 |         "PostType::p126",
217 |         "PostType::p125",
218 |         "PostType::p124"
219 |       ]
220 |     }
221 |   }
222 | };
223 | 
224 | export const back1QueryBadArgs = `
225 | query {
226 |   getRecentPosts(last:1, afterCursor:"foo") {
227 |     _id,
228 |     cursor
229 |   }
230 | }`;
231 | 
232 | export const front1After3DenormalizedFn = (requestAmount) => {
233 |   const base = {
234 |     data: {
235 |       "getRecentPosts": [
236 |         {
237 |           "_id": "p123",
238 |           "cursor": "1411111111111chikachikow"
239 |         }
240 |       ]
241 |     }
242 |   };
243 |   base.data.getRecentPosts.EOF = true;
244 |   if (requestAmount !== undefined) {
245 |     base.data.getRecentPosts.count = requestAmount;
246 |   }
247 |   return base;
248 | };
249 | 
250 | export const front4PostStoreNoCursors = {
251 |   "entities": {
252 |     "PostType": {
253 |       "p126": {
254 |         "_id": "p126"
255 |       },
256 |       "p125": {
257 |         "_id": "p125"
258 |       },
259 |       "p124": {
260 |         "_id": "p124"
261 |       },
262 |       "p123": {
263 |         "_id": "p123"
264 |       }
265 |     }
266 |   },
267 |   "result": {
268 |     "getRecentPosts": {
269 |       "front": [
270 |         "PostType::p126",
271 |         "PostType::p125",
272 |         "PostType::p124",
273 |         "PostType::p123"
274 |       ]
275 |     }
276 |   }
277 | };
278 | 
279 | export const back4PostStoreNoLastCursor = {
280 |   "entities": {
281 |     "PostType": {
282 |       "p126": {
283 |         "_id": "p126"
284 |       },
285 |       "p125": {
286 |         "_id": "p125",
287 |         "cursor": "1433333333333chikachikow"
288 |       },
289 |       "p124": {
290 |         "_id": "p124",
291 |         "cursor": "1422222222222chikachikow"
292 |       },
293 |       "p123": {
294 |         "_id": "p123",
295 |         "cursor": "1411111111111chikachikow"
296 |       }
297 |     }
298 |   },
299 |   "result": {
300 |     "getRecentPosts": {
301 |       "back": [
302 |         "PostType::p126",
303 |         "PostType::p125",
304 |         "PostType::p124",
305 |         "PostType::p123"
306 |       ]
307 |     }
308 |   }
309 | };
310 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/data-union.js:
--------------------------------------------------------------------------------
  1 | export const unionQueryString = `
  2 | query {
  3 |   getGroup(_id: "g123") {
  4 |     _id
  5 |     owner {
  6 |       __typename
  7 |       ... on AuthorType {
  8 |         _id
  9 |         name
 10 |         twitterHandle
 11 |       }
 12 |     }
 13 |     members {
 14 |       __typename
 15 |       ... on AuthorType {
 16 |         _id
 17 |         name
 18 |       }
 19 |       ... on Group {
 20 |         _id
 21 |         members {
 22 |           __typename
 23 |           ... on AuthorType {
 24 |             _id
 25 |             name
 26 |           }
 27 |         }
 28 |       }
 29 |     }
 30 |   }
 31 | }`;
 32 | 
 33 | export const unionResponse = {
 34 |   "data": {
 35 |     "getGroup": {
 36 |       "_id": "g123",
 37 |       "owner": {
 38 |         "__typename": "AuthorType",
 39 |         "_id": "a123",
 40 |         "name": "Matt K",
 41 |         "twitterHandle": "@__mattk"
 42 |       },
 43 |       "members": [
 44 |         {
 45 |           "__typename": "AuthorType",
 46 |           "_id": "a123",
 47 |           "name": "Matt K"
 48 |         },
 49 |         {
 50 |           "__typename": "AuthorType",
 51 |           "_id": "a124",
 52 |           "name": "Joe J"
 53 |         }
 54 |       ]
 55 |     }
 56 |   }
 57 | };
 58 | 
 59 | 
 60 | export const unionStoreFull = {
 61 |   "entities": {
 62 |     "Group": {
 63 |       "g123": {
 64 |         "_id": "g123",
 65 |         "owner": "AuthorType::a123",
 66 |         "members": [
 67 |           "AuthorType::a123",
 68 |           "AuthorType::a124"
 69 |         ]
 70 |       }
 71 |     },
 72 |     "AuthorType": {
 73 |       "a123": {
 74 |         "_id": "a123",
 75 |         "name": "Matt K",
 76 |         "twitterHandle": "@__mattk"
 77 |       },
 78 |       "a124": {
 79 |         "_id": "a124",
 80 |         "name": "Joe J"
 81 |       }
 82 |     }
 83 |   },
 84 |   "result": {
 85 |     "getGroup": {
 86 |       "{\"_id\":\"g123\"}": "Group::g123"
 87 |     }
 88 |   }
 89 | };
 90 | 
 91 | export const unionStoreMissingOwnerMembers = {
 92 |   "entities": {
 93 |     "Group": {
 94 |       "g123": {
 95 |         "_id": "g123"
 96 |       }
 97 |     },
 98 |     "AuthorType": {
 99 |       "a124": {
100 |         "_id": "a124",
101 |         "name": "Joe J"
102 |       }
103 |     }
104 |   },
105 |   "result": {
106 |     "getGroup": {
107 |       "{\"_id\":\"g123\"}": "Group::g123"
108 |     }
109 |   }
110 | };
111 | 
112 | export const unionMissingOwnerMembersDenormalized = {
113 |   "getGroup": {
114 |     "_id": "g123",
115 |     "owner": {
116 |       "__typename": null,
117 |       "_id": null,
118 |       "name": null,
119 |       "twitterHandle": null
120 |     },
121 |     "members": []
122 |   }
123 | };
124 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/data.js:
--------------------------------------------------------------------------------
 1 | export const emptyInitialState = {
 2 |   entities: {},
 3 |   result: {}
 4 | };
 5 | 
 6 | export const paginationWords = {
 7 |   first: 'first',
 8 |   last: 'last',
 9 |   before: 'beforeCursor',
10 |   after: 'afterCursor'
11 | };
12 | 
13 | export const coerceTypes = {
14 |   DateTime: val => new Date(val)
15 | };
16 | 
17 | export const queryWithSortedArgs = `
18 | query ($reverse: Boolean, $lang: String) {
19 |   getLatestPost {
20 |     _id
21 | 		title(inReverse: $reverse, language: $lang)
22 |   }
23 | }`;
24 | 
25 | export const responseFromSortedArgs = {
26 |   "data": {
27 |     "getLatestPost": {
28 |       "_id": "p126",
29 |       "title": "!LONAPSE NE ?atad dezilamroned erots yahsac seod woH"
30 |     }
31 |   }
32 | };
33 | 
34 | export const storeFromSortedArgs = {
35 |   "entities": {
36 |     "PostType": {
37 |       "p126": {
38 |         "_id": "p126",
39 |         "title": {
40 |           "{\"inReverse\":true,\"language\":\"spanish\"}": "!LONAPSE NE ?atad dezilamroned erots yahsac seod woH"
41 |         }
42 |       }
43 |     }
44 |   },
45 |   "result": {
46 |     "getLatestPost": "PostType::p126"
47 |   }
48 | };
49 | 
50 | export const queryPostCount = `
51 |   query {
52 |     postCount: getPostCount
53 |   }`;
54 | 
55 | export const storedPostCount = {
56 |   "result": {
57 |     "getPostCount": 4
58 |   }
59 | };
60 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/denormalizeStore-tests.js:
--------------------------------------------------------------------------------
  1 | import test from 'ava';
  2 | import 'babel-register';
  3 | import {buildExecutionContext} from '../../utils';
  4 | import denormalizeStore from '../denormalizeStore';
  5 | import {
  6 |   unionQueryString,
  7 |   unionStoreFull,
  8 |   unionResponse,
  9 |   unionStoreMissingOwnerMembers,
 10 |   unionMissingOwnerMembersDenormalized
 11 | } from './data-union';
 12 | import {
 13 |   paginationWords,
 14 |   emptyInitialState,
 15 |   queryWithSortedArgs,
 16 |   responseFromSortedArgs,
 17 |   storeFromSortedArgs,
 18 |   queryPostCount,
 19 |   storedPostCount,
 20 |   coerceTypes
 21 | } from './data';
 22 | import clientSchema from '../../__tests__/clientSchema.json';
 23 | import {
 24 |   back1Query,
 25 |   back1StoreNoCursor,
 26 |   back1NoCursorDenormalizedFn,
 27 |   back1QueryBadArgs,
 28 |   back1Store,
 29 |   back1Skip1Query,
 30 |   fullPostStore,
 31 |   front1After3DenormalizedFn,
 32 |   front4PostStore,
 33 |   front4PostStoreNoCursors,
 34 |   back4PostStoreNoLastCursor
 35 | } from './data-pagination';
 36 | 
 37 | import {back4,back4ResponseFn, back2After3Query} from './data-pagination-back'
 38 | import {front2After3Query, front3Store, front4Query, front3LocalResponseFn} from './data-pagination-front';
 39 | import {parse} from '../../utils';
 40 | import parseAndInitializeQuery from '../../query/parseAndInitializeQuery';
 41 | 
 42 | const idFieldName = '_id';
 43 | 
 44 | test('denormalize store from recursive union request', t => {
 45 |   const queryAST = parseAndInitializeQuery(unionQueryString, clientSchema, idFieldName);
 46 |   const context = buildExecutionContext(queryAST, {
 47 |     coerceTypes,
 48 |     getState: () => unionStoreFull,
 49 |     idFieldName,
 50 |     schema: clientSchema,
 51 |     paginationWords
 52 |   });
 53 |   const actual = denormalizeStore(context);
 54 |   const {data: expected} = unionResponse;
 55 |   t.deepEqual(actual, expected);
 56 | });
 57 | 
 58 | test('denormalize store when the query returns a scalar (String)', t => {
 59 |   const queryAST = parseAndInitializeQuery(queryPostCount, clientSchema, idFieldName);
 60 |   const context = buildExecutionContext(queryAST, {
 61 |     coerceTypes,
 62 |     getState: () => storedPostCount,
 63 |     idFieldName,
 64 |     schema: clientSchema,
 65 |     paginationWords
 66 |   });
 67 |   const actual = denormalizeStore(context);
 68 |   const expected = {"postCount": 4};
 69 |   t.deepEqual(actual, expected);
 70 | });
 71 | 
 72 | test('denormalize store with missing scalar data', t => {
 73 |   const queryAST = parseAndInitializeQuery(back1Query, clientSchema, idFieldName);
 74 |   const context = buildExecutionContext(queryAST, {
 75 |     coerceTypes,
 76 |     getState: () => back1StoreNoCursor,
 77 |     idFieldName,
 78 |     schema: clientSchema,
 79 |     paginationWords
 80 |   });
 81 |   const actual = denormalizeStore(context);
 82 |   const expected = back1NoCursorDenormalizedFn();
 83 |   t.deepEqual(actual, expected);
 84 | });
 85 | 
 86 | test('denormalize store with missing entity and array', t => {
 87 |   const queryAST = parseAndInitializeQuery(unionQueryString, clientSchema, idFieldName);
 88 |   const context = buildExecutionContext(queryAST, {
 89 |     coerceTypes,
 90 |     getState: () => unionStoreMissingOwnerMembers,
 91 |     idFieldName,
 92 |     schema: clientSchema,
 93 |     paginationWords
 94 |   });
 95 |   const actual = denormalizeStore(context);
 96 |   const expected = unionMissingOwnerMembersDenormalized;
 97 |   t.deepEqual(actual, expected);
 98 | });
 99 | 
100 | test('throws on bad pagination args', t => {
101 |   const queryAST = parseAndInitializeQuery(back1QueryBadArgs, clientSchema, idFieldName);
102 |   const context = buildExecutionContext(queryAST, {
103 |     coerceTypes,
104 |     getState: () => back1Store,
105 |     idFieldName,
106 |     schema: clientSchema,
107 |     paginationWords
108 |   });
109 |   t.throws(() => denormalizeStore(context), 'Supplying pagination cursors to cashay is not supported. undefined');
110 | });
111 | 
112 | test('denormalize store with scalar fields with args', t => {
113 |   const queryAST = parseAndInitializeQuery(queryWithSortedArgs, clientSchema, idFieldName);
114 |   const context = buildExecutionContext(queryAST, {
115 |     coerceTypes,
116 |     getState: () => storeFromSortedArgs,
117 |     idFieldName,
118 |     schema: clientSchema,
119 |     paginationWords,
120 |     variables: {reverse: true, lang: "spanish"}
121 |   });
122 |   const actual = denormalizeStore(context);
123 |   const {data: expected} = responseFromSortedArgs;
124 |   t.deepEqual(actual, expected);
125 | });
126 | 
127 | test('get a page from a full store (back)', t => {
128 |   const queryAST = parseAndInitializeQuery(back4, clientSchema, idFieldName);
129 |   const context = buildExecutionContext(queryAST, {
130 |     coerceTypes,
131 |     getState: () => fullPostStore,
132 |     idFieldName,
133 |     schema: clientSchema,
134 |     paginationWords,
135 |     variables: {reverse: true, lang: "spanish"}
136 |   });
137 |   const actual = denormalizeStore(context);
138 |   const {data: expected} = back4ResponseFn(4);
139 |   t.deepEqual(actual, expected);
140 | });
141 | 
142 | test('request an array that does not exist in the state', t => {
143 |   const queryAST = parseAndInitializeQuery(back1Query, clientSchema, idFieldName);
144 |   const context = buildExecutionContext(queryAST, {
145 |     coerceTypes,
146 |     getState: () => emptyInitialState,
147 |     idFieldName,
148 |     schema: clientSchema,
149 |     paginationWords,
150 |     variables: {reverse: true, lang: "spanish"}
151 |   });
152 |   const actual = denormalizeStore(context);
153 |   const expected = {"getRecentPosts": []};
154 |   t.deepEqual(actual, expected);
155 | });
156 | 
157 | test('flag sendToServer = true for array of objects', t => {
158 |   const rawQuery = `
159 |   query {
160 |     getPostById (_id: "p126") {
161 |       _id
162 |       keywordsMentioned {
163 |         word
164 |       }
165 |     }
166 |   }`;
167 |   const queryAST = parseAndInitializeQuery(rawQuery, clientSchema, idFieldName);
168 |   const context = buildExecutionContext(queryAST, {
169 |     coerceTypes,
170 |     getState: () => emptyInitialState,
171 |     idFieldName,
172 |     schema: clientSchema
173 |   });
174 |   denormalizeStore(context);
175 |   //                                    getPostById ->           keywordsMentioned ->       word
176 |   t.true(context.operation.selectionSet.selections[0].selectionSet.selections[1].selectionSet.selections[0].sendToServer);
177 | });
178 | 
179 | test('Same query with another argument', t => {
180 |   const rawQuery = `
181 |   query {
182 |     getCommentsByPostId {
183 |       _id
184 |       postId
185 |       content
186 |     }
187 |   }`;
188 |   const queryAST = parseAndInitializeQuery(rawQuery, clientSchema, idFieldName);
189 |   const context = buildExecutionContext(queryAST, {
190 |     variables: {"postId": "p126"},
191 |     coerceTypes,
192 |     getState: () => ({entities:{}, result: {getCommentsByPostId: {'"postId": "p123"':[]}}}),
193 |     idFieldName,
194 |     paginationWords,
195 |     schema: clientSchema
196 |   });
197 |   const actual = denormalizeStore(context);
198 |   const expected = {getCommentsByPostId:[{_id:null,postId:null,content:null}]}
199 |   t.deepEqual(actual, expected)
200 | });
201 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/mergeStores-tests.js:
--------------------------------------------------------------------------------
  1 | import test from 'ava';
  2 | import 'babel-register';
  3 | import mergeStores from '../mergeStores';
  4 | 
  5 | import {
  6 |   front3Store,
  7 |   front2After3StoreFn,
  8 |   front1After3Store,
  9 |   front1After4StoreFn
 10 | } from './data-pagination-front';
 11 | import {
 12 |   back3Store,
 13 |   back1After4StoreFn
 14 | } from './data-pagination-back';
 15 | 
 16 | import {
 17 |   fullPostStore,
 18 |   front4PostStore,
 19 |   back4PostStore,
 20 |   back1Store,
 21 |   front3Back1Store
 22 | } from './data-pagination';
 23 | 
 24 | test('merge docs 1-3 with doc 4 that has EOF == true', t => {
 25 |   const firstDocs = front3Store;
 26 |   const lastDoc = front2After3StoreFn();
 27 |   const actual = mergeStores(firstDocs, lastDoc);
 28 |   const expected = fullPostStore;
 29 |   t.deepEqual(actual, expected);
 30 | });
 31 | 
 32 | test('merge docs 1-3 with doc 4', t => {
 33 |   const firstDocs = front3Store;
 34 |   const lastDoc = front1After3Store;
 35 |   const actual = mergeStores(firstDocs, lastDoc);
 36 |   const expected = front4PostStore;
 37 |   t.deepEqual(actual, expected);
 38 | });
 39 | 
 40 | test('merge docs 1-4 with an empty doc 5 request (front)', t => {
 41 |   const firstDocs = front4PostStore;
 42 |   const lastDoc = front1After4StoreFn();
 43 |   const actual = mergeStores(firstDocs, lastDoc);
 44 |   const expected = fullPostStore;
 45 |   t.deepEqual(actual, expected);
 46 | });
 47 | 
 48 | test('merge docs 1-4 with an empty doc 5 request (back)', t => {
 49 |   const firstDocs = back4PostStore;
 50 |   const lastDoc = back1After4StoreFn();
 51 |   const actual = mergeStores(firstDocs, lastDoc);
 52 |   const expected = fullPostStore;
 53 |   t.deepEqual(actual, expected);
 54 | });
 55 | 
 56 | test('merge docs 1-3 with back 1', t => {
 57 |   const firstDocs = front3Store;
 58 |   const lastDoc = back1Store;
 59 |   const actual = mergeStores(firstDocs, lastDoc);
 60 |   const expected = front3Back1Store;
 61 |   t.deepEqual(actual, expected);
 62 | });
 63 | 
 64 | test('merge docs 1-3 with back 1-3', t => {
 65 |   const firstDocs = front3Store;
 66 |   const lastDoc = back3Store;
 67 |   const actual = mergeStores(firstDocs, lastDoc);
 68 |   const expected = fullPostStore;
 69 |   t.deepEqual(actual, expected);
 70 | });
 71 | 
 72 | test('merge permutation: target: back, src: back', t => {
 73 |   const state = {back: [3, 4, 5]};
 74 |   const src = {back: [0, 1, 2]};
 75 |   const actual = mergeStores(state, src);
 76 |   const expected = {back: [0, 1, 2, 3, 4, 5]};
 77 |   t.deepEqual(actual, expected);
 78 | });
 79 | 
 80 | test('merge permutation: target: back, src: front, EOF: false', t => {
 81 |   const state = {back: [3, 4, 5]};
 82 |   const src = {front: [0, 1, 2]};
 83 |   const actual = mergeStores(state, src);
 84 |   const expected = {front: [0, 1, 2], back: [3, 4, 5]};
 85 |   t.deepEqual(actual, expected);
 86 | });
 87 | 
 88 | test('merge permutation: target: back, src: front, EOF: true', t => {
 89 |   const state = {back: [3, 4, 5]};
 90 |   const src = {front: [1, 2, 3]};
 91 |   const actual = mergeStores(state, src);
 92 |   const expected = {full: [1, 2, 3, 4, 5]};
 93 |   t.deepEqual(actual, expected);
 94 | });
 95 | 
 96 | test('merge permutation: target: back, src: full', t => {
 97 |   const state = {back: [3, 4, 5]};
 98 |   const src = {full: [0, 1, 2]};
 99 |   const actual = mergeStores(state, src);
100 |   const expected = {full: [0, 1, 2]};
101 |   t.deepEqual(actual, expected);
102 | });
103 | 
104 | test('merge permutation: target: back, src: front, back, EOF: false', t => {
105 |   const state = {back: [3, 4, 5]};
106 |   const src = {front: [0, 1], back: [2, 3]};
107 |   const actual = mergeStores(state, src);
108 |   const expected = {front: [0, 1], back: [2, 3, 4, 5]};
109 |   t.deepEqual(actual, expected);
110 | });
111 | 
112 | test('merge permutation: target: back, src: front, back, EOF: true', t => {
113 |   const state = {back: [3, 4, 5]};
114 |   const src = {front: [0, 1], back: [1, 2, 3]};
115 |   const actual = mergeStores(state, src);
116 |   const expected = {full: [0, 1, 2, 3, 4, 5]};
117 |   t.deepEqual(actual, expected);
118 | });
119 | 
120 | test('merge permutation: target: front, src: back, EOF: false', t => {
121 |   const state = {front: [0, 1, 2]};
122 |   const src = {back: [3, 4, 5]};
123 |   const actual = mergeStores(state, src);
124 |   const expected = {front: [0, 1, 2], back: [3, 4, 5]};
125 |   t.deepEqual(actual, expected);
126 | });
127 | 
128 | test('merge permutation: target: front, src: back, EOF: true', t => {
129 |   const state = {front: [0, 1, 2]};
130 |   const src = {back: [2, 3, 4, 5]};
131 |   const actual = mergeStores(state, src);
132 |   const expected = {full: [0, 1, 2, 3, 4, 5]};
133 |   t.deepEqual(actual, expected);
134 | });
135 | 
136 | test('merge permutation: target: front, src: front', t => {
137 |   const state = {front: [1, 2, 3]};
138 |   const src = {front: [3, 4, 5]};
139 |   const actual = mergeStores(state, src);
140 |   const expected = {front: [1, 2, 3, 4, 5]};
141 |   t.deepEqual(actual, expected);
142 | });
143 | 
144 | test('merge permutation: target: front, src: full', t => {
145 |   const state = {front: [1, 2, 3]};
146 |   const src = {full: [3, 4, 5]};
147 |   const actual = mergeStores(state, src);
148 |   const expected = {full: [3, 4, 5]};
149 |   t.deepEqual(actual, expected);
150 | });
151 | 
152 | test('merge permutation: target: front, src: front, back, EOF: false', t => {
153 |   const state = {front: [1, 2, 3]};
154 |   const src = {front: [3, 4], back: [5]};
155 |   const actual = mergeStores(state, src);
156 |   const expected = {front: [1, 2, 3, 4], back: [5]};
157 |   t.deepEqual(actual, expected);
158 | });
159 | 
160 | test('merge permutation: target: front, src: front, back, EOF: true', t => {
161 |   const state = {front: [1, 2, 3]};
162 |   const src = {front: [3, 4], back: [4, 5]};
163 |   const actual = mergeStores(state, src);
164 |   const expected = {full: [1, 2, 3, 4, 5]};
165 |   t.deepEqual(actual, expected);
166 | });
167 | 
168 | test('merge permutation: target: front, back, src: back, EOF: false', t => {
169 |   const state = {front: [1, 2, 3], back: [5]};
170 |   const src = {back: [4]};
171 |   const actual = mergeStores(state, src);
172 |   const expected = {front: [1, 2, 3], back: [4, 5]};
173 |   t.deepEqual(actual, expected);
174 | });
175 | 
176 | test('merge permutation: target: front, back, src: back, EOF: true', t => {
177 |   const state = {front: [1, 2, 3], back: [5]};
178 |   const src = {back: [3, 4]};
179 |   const actual = mergeStores(state, src);
180 |   const expected = {full: [1, 2, 3, 4, 5]};
181 |   t.deepEqual(actual, expected);
182 | });
183 | 
184 | test('merge permutation: target: front, back, src: front, EOF: false', t => {
185 |   const state = {front: [1, 2, 3], back: [5]};
186 |   const src = {front: [4]};
187 |   const actual = mergeStores(state, src);
188 |   const expected = {front: [1, 2, 3, 4], back: [5]};
189 |   t.deepEqual(actual, expected);
190 | });
191 | 
192 | test('merge permutation: target: front, back, src: front, EOF: true', t => {
193 |   const state = {front: [1, 2, 3], back: [5]};
194 |   const src = {front: [4, 5]};
195 |   const actual = mergeStores(state, src);
196 |   const expected = {full: [1, 2, 3, 4, 5]};
197 |   t.deepEqual(actual, expected);
198 | });
199 | 
200 | test('merge permutation: target: front, back, src: full', t => {
201 |   const state = {front: [1, 2, 3], back: [5]};
202 |   const src = {full: [1, 2, 3, 4]};
203 |   const actual = mergeStores(state, src);
204 |   const expected = {full: [1, 2, 3, 4]};
205 |   t.deepEqual(actual, expected);
206 | });
207 | 
208 | test('merge permutation: target: front, back, src: front, back, EOF: false', t => {
209 |   const state = {front: [1, 2], back: [5]};
210 |   const src = {front: [3], back: [4]};
211 |   const actual = mergeStores(state, src);
212 |   const expected = {front: [1, 2, 3], back: [4, 5]};
213 |   t.deepEqual(actual, expected);
214 | });
215 | 
216 | test('merge permutation: target: front, back, src: front, back, EOF: true', t => {
217 |   const state = {front: [1, 2], back: [5]};
218 |   const src = {front: [3, 4], back: [4]};
219 |   const actual = mergeStores(state, src);
220 |   const expected = {full: [1, 2, 3, 4, 5]};
221 |   t.deepEqual(actual, expected);
222 | });
223 | 
224 | test('merge permutation: target: full, src: back', t => {
225 |   const state = {full: [1, 2, 3]};
226 |   const src = {back: [4, 5]};
227 |   const actual = mergeStores(state, src);
228 |   const expected = {full: [1, 2, 3, 4, 5]};
229 |   t.deepEqual(actual, expected);
230 | });
231 | 
232 | test('merge permutation: target: full, src: front', t => {
233 |   const state = {full: [1, 2, 3]};
234 |   const src = {front: [0, 3]};
235 |   const actual = mergeStores(state, src);
236 |   const expected = {full: [0, 1, 2, 3]};
237 |   t.deepEqual(actual, expected);
238 | });
239 | 
240 | test('merge permutation: target: full, src: full', t => {
241 |   const state = {full: [1, 2, 3]};
242 |   const src = {full: [0, 3, 4, 5, 2]};
243 |   const actual = mergeStores(state, src);
244 |   const expected = {full: [1, 2, 3, 0, 4, 5]};
245 |   t.deepEqual(actual, expected);
246 | });
247 | 
248 | //   test('array mutation: delete a doc', t => {
249 | //     const state = {full: [1, 2, 3]};
250 | //     const src = {full: [1, 2]};
251 | //     const actual = mergeStores(state, src, true);
252 | //     const expected = {full: [1, 2]};
253 | //     t.deepEqual(actual, expected);
254 | //   });
255 | //
256 | // test('array mutation: move a doc', t => {
257 | //   const state = {full: [1, 2, 3]};
258 | //   const src = {full: [1, 3, 2]};
259 | //   const actual = mergeStores(state, src, true);
260 | //   const expected = {full: [1, 3, 2]};
261 | //   t.deepEqual(actual, expected);
262 | // });
263 | //
264 | // test('array mutation: replace a doc', t => {
265 | //   const state = {full: [1, 2, 3]};
266 | //   const src = {full: [1, 4, 3]};
267 | //   const actual = mergeStores(state, src, true);
268 | //   const expected = {full: [1, 4, 3]};
269 | //   t.deepEqual(actual, expected);
270 | // });
271 | //
272 | // test('array mutation: replace 2 docs with 3 new docs', t => {
273 | //   const state = {full: [1, 2, 3]};
274 | //   const src = {full: [9, 2, 8, 6]};
275 | //   const actual = mergeStores(state, src, true);
276 | //   const expected = {full: [9, 2, 8, 6]};
277 | //   t.deepEqual(actual, expected);
278 | // });
279 | 


--------------------------------------------------------------------------------
/src/normalize/__tests__/normalizeResponse-tests.js:
--------------------------------------------------------------------------------
 1 | import test from 'ava';
 2 | import 'babel-register';
 3 | import clientSchema from '../../__tests__/clientSchema.json';
 4 | import normalizeResponse from '../normalizeResponse';
 5 | import {buildExecutionContext} from '../../utils';
 6 | import {unionQueryString, unionStoreFull, unionResponse} from './data-union';
 7 | import {clone} from '../../utils';
 8 | 
 9 | import {
10 |   front3Query,
11 |   front3Response,
12 |   front3Store,
13 |   front2After3Query,
14 |   front1After3Response,
15 |   front2After3StoreFn,
16 |   front4Query,
17 |   front1After3Store,
18 |   front1After4Query,
19 |   front1After4Response,
20 |   front1After4StoreFn
21 | } from './data-pagination-front';
22 | import {
23 |   back3Query,
24 |   back3Response,
25 |   back3Store,
26 |   back2After3Query,
27 |   back1After3Response,
28 |   back2After3StoreFn,
29 |   back4,
30 |   back1After3Store,
31 |   back1After4Query,
32 |   back1After4Response,
33 |   back1After4StoreFn
34 | } from './data-pagination-back';
35 | import {parse} from '../../utils';
36 | import {paginationWords} from './data';
37 | 
38 | test('normalizes unions', t => {
39 |   const queryAST = parse(unionQueryString);
40 |   const context = buildExecutionContext(queryAST, {idFieldName: '_id', schema: clientSchema, paginationWords});
41 |   const actual = normalizeResponse(unionResponse.data, context);
42 |   const expected = unionStoreFull;
43 |   t.deepEqual(actual, expected);
44 | });
45 | 
46 | 
47 | test('normalize pagination: front 3', t => {
48 |   const queryAST = parse(front3Query);
49 |   const context = buildExecutionContext(queryAST, {idFieldName: '_id', schema: clientSchema, paginationWords});
50 |   const actual = normalizeResponse(front3Response.data, context);
51 |   const expected = front3Store;
52 |   t.deepEqual(actual, expected);
53 | });
54 | 
55 | test('normalize back pagination: back 3', t => {
56 |   const queryAST = parse(back3Query);
57 |   const context = buildExecutionContext(queryAST, {idFieldName: '_id', schema: clientSchema, paginationWords});
58 |   const actual = normalizeResponse(back3Response.data, context);
59 |   const expected = back3Store;
60 |   t.deepEqual(actual, expected);
61 | });
62 | 


--------------------------------------------------------------------------------
/src/normalize/addDeps.js:
--------------------------------------------------------------------------------
 1 | import {DELIMITER as _} from '../utils';
 2 | 
 3 | export default function addDeps(normalizedResponse, op, key, normalizedDeps, denormalizedDeps) {
 4 |   // get the previous set
 5 |   // create a Set of normalized locations in entities (eg 'Post.123')
 6 |   const newNormalizedDeps = makeNormalizedDeps(normalizedResponse.entities);
 7 |   let oldNormalizedDeps;
 8 |   normalizedDeps[op] = normalizedDeps[op] || {};
 9 |   const opDeps = normalizedDeps[op];
10 |   oldNormalizedDeps = opDeps[key];
11 |   opDeps[key] = newNormalizedDeps;
12 |   let newUniques;
13 |   if (!oldNormalizedDeps) {
14 |     newUniques = newNormalizedDeps;
15 |   } else {
16 |     // create 2 Sets that are the left/right diff of old and new
17 |     newUniques = new Set();
18 |     for (let dep of newNormalizedDeps) {
19 |       if (oldNormalizedDeps.has(dep)) {
20 |         oldNormalizedDeps.delete(dep);
21 |       } else {
22 |         newUniques.add(dep);
23 |       }
24 |     }
25 | 
26 |     // remove old deps
27 |     for (let dep of oldNormalizedDeps) {
28 |       const [typeName, entityName] = dep.split(_);
29 |       const entityDep = denormalizedDeps[typeName][entityName];
30 |       entityDep[op].delete(key);
31 |     }
32 |   }
33 | 
34 |   // add new deps
35 |   for (let dep of newUniques) {
36 |     const [typeName, entityName] = dep.split(_);
37 |     denormalizedDeps[typeName] = denormalizedDeps[typeName] || {};
38 |     denormalizedDeps[typeName][entityName] = denormalizedDeps[typeName][entityName] || {};
39 |     denormalizedDeps[typeName][entityName][op] = denormalizedDeps[typeName][entityName][op] || new Set();
40 |     denormalizedDeps[typeName][entityName][op].add(key);
41 |   }
42 | }
43 | 
44 | const makeNormalizedDeps = entities => {
45 |   const typeKeys = Object.keys(entities);
46 |   const normalizedDeps = new Set();
47 |   for (let i = 0; i < typeKeys.length; i++) {
48 |     const typeName = typeKeys[i];
49 |     const entityKeys = Object.keys(entities[typeName]);
50 |     for (let j = 0; j < entityKeys.length; j++) {
51 |       const entityName = entityKeys[j];
52 |       const dep = `${typeName}${_}${entityName}`;
53 |       normalizedDeps.add(dep);
54 |     }
55 |   }
56 |   return normalizedDeps;
57 | };
58 | 


--------------------------------------------------------------------------------
/src/normalize/denormalizeHelpers.js:
--------------------------------------------------------------------------------
  1 | import {INLINE_FRAGMENT} from 'graphql/language/kinds';
  2 | import {TypeKind} from 'graphql/type/introspection';
  3 | import getFieldState from './getFieldState';
  4 | import {
  5 |   defaultResolveChannelKeyFactory,
  6 |   isLive,
  7 |   makeFullChannel,
  8 |   NORM_DELIMITER
  9 | } from '../utils';
 10 | const {UNION, LIST, SCALAR, ENUM} = TypeKind;
 11 | 
 12 | export const handleMissingData = (visitObject, field, nnFieldType, cachedDirective, context) => {
 13 |   if (!cachedDirective) {
 14 |     sendChildrenToServer(field);
 15 |   }
 16 |   if (nnFieldType.kind === SCALAR) {
 17 |     return null;
 18 |   } else if (nnFieldType.kind === LIST) {
 19 |     return [];
 20 |   } else if (nnFieldType.kind === ENUM) {
 21 |     return '';
 22 |   } else {
 23 |     const typeSchema = context.schema.types[nnFieldType.name];
 24 |     if (nnFieldType.kind === UNION) {
 25 |       // since we don't know what the shape will look like, make it look like everything
 26 |       // that way, we don't have to code defensively in the view layer
 27 |       const {possibleTypes} = typeSchema;
 28 |       const possibleTypesKeys = Object.keys(possibleTypes);
 29 |       const unionResponse = {};
 30 |       for (let i = 0; i < possibleTypesKeys.length; i++) {
 31 |         const possibleTypeKey = possibleTypesKeys[i];
 32 |         const typeSchema = context.schema.types[possibleTypeKey];
 33 |         Object.assign(unionResponse, visitObject(unionResponse, field, typeSchema, context));
 34 |       }
 35 |       return {...unionResponse, __typename: null};
 36 |     }
 37 |     return visitObject({}, field, typeSchema, context);
 38 |   }
 39 | };
 40 | 
 41 | export const calculateSendToServer = (field, idFieldName) => {
 42 |   const {selections} = field.selectionSet;
 43 |   for (let i = 0; i < selections.length; i++) {
 44 |     const selection = selections[i];
 45 |     if (selection.kind === INLINE_FRAGMENT) {
 46 |       calculateSendToServer(selection, idFieldName);
 47 |     }
 48 |     if (selection.sendToServer) {
 49 |       field.sendToServer = true;
 50 |     }
 51 |   }
 52 | };
 53 | 
 54 | export const sendChildrenToServer = reqAST => {
 55 |   reqAST.sendToServer = true;
 56 |   if (!reqAST.selectionSet) {
 57 |     return;
 58 |   }
 59 |   reqAST.selectionSet.selections.forEach(child => {
 60 |     sendChildrenToServer(child);
 61 |   })
 62 | };
 63 | 
 64 | export const rebuildOriginalArgs = reqAST => {
 65 |   if (reqAST.originalArguments) {
 66 |     reqAST.arguments = reqAST.originalArguments;
 67 |   }
 68 |   if (reqAST.selectionSet) {
 69 |     const fields = reqAST.selectionSet.selections;
 70 |     for (let i = 0; i < fields.length; i++) {
 71 |       rebuildOriginalArgs(fields[i]);
 72 |     }
 73 |   }
 74 | };
 75 | 
 76 | export const splitNormalString = (normalString) => {
 77 |   const splitPoint = normalString.indexOf(NORM_DELIMITER);
 78 |   if (splitPoint !== -1) {
 79 |     return [normalString.substr(0, splitPoint), normalString.substr(splitPoint + NORM_DELIMITER.length)]
 80 |   } else {
 81 |     return [normalString];
 82 |   }
 83 | };
 84 | 
 85 | export const maybeLiveQuery = (source, fieldSchema, field, nnFieldType, context) => {
 86 |   const fieldName = field.name.value;
 87 |   if (!isLive(field.directives)) {
 88 |     // if there's no results stored or being fetched, save some time & don't bother with the args
 89 |     return getFieldState(source[fieldName], fieldSchema, field, context);
 90 |   }
 91 |   const aliasOrFieldName = field.alias && field.alias.value || fieldName;
 92 |   const {resolveChannelKey, subscriber, idFieldName, getState, queryDep, subscribe, subscriptionDeps, variables} = context;
 93 |   const result = getState().result;
 94 |   const topLevelSource = source === result;
 95 |   const fieldResolveChannelKey = resolveChannelKey && resolveChannelKey[aliasOrFieldName];
 96 |   const fieldSubscriber = subscriber && subscriber[aliasOrFieldName];
 97 |   const bestSubscriber = fieldSubscriber || context.defaultSubscriber;
 98 |   const makeChannelKey = fieldResolveChannelKey || defaultResolveChannelKeyFactory(idFieldName, topLevelSource);
 99 |   const channelKey = makeChannelKey(source, variables);
100 |   const initialState = subscribe(aliasOrFieldName, channelKey, bestSubscriber, {returnType: nnFieldType});
101 |   const subDep = makeFullChannel(aliasOrFieldName, channelKey);
102 |   subscriptionDeps[subDep] = subscriptionDeps[subDep] || new Set();
103 |   subscriptionDeps[subDep].add(queryDep);
104 |   return result[aliasOrFieldName] && result[aliasOrFieldName][channelKey] || initialState.data;
105 | };
106 | 


--------------------------------------------------------------------------------
/src/normalize/denormalizeStore.js:
--------------------------------------------------------------------------------
  1 | import {TypeKind} from 'graphql/type/introspection';
  2 | import {INLINE_FRAGMENT} from 'graphql/language/kinds';
  3 | import {
  4 |   ensureRootType,
  5 |   ensureTypeFromNonNull,
  6 |   CACHED,
  7 |   getFieldSchema,
  8 |   isLive,
  9 |   makeCachedArgs,
 10 |   TYPENAME,
 11 |   parseCachedType
 12 | } from '../utils';
 13 | import {
 14 |   calculateSendToServer,
 15 |   handleMissingData,
 16 |   splitNormalString,
 17 |   maybeLiveQuery
 18 | } from './denormalizeHelpers';
 19 | import getCachedFieldState from './getCachedFieldState';
 20 | 
 21 | const {ENUM, LIST, SCALAR} = TypeKind;
 22 | 
 23 | const arrayMetadata = ['BOF', 'EOF', 'count'];
 24 | const isPrimitive = (kind) => kind === SCALAR || kind === ENUM;
 25 | const visitObject = (subState = {}, reqAST, parentTypeSchema, context, reduction = {}) => {
 26 |   if (typeof subState === 'string') {
 27 |     const [typeName, docId] = splitNormalString(subState);
 28 |     const {entities} = context.getState();
 29 |     // code defensively because an @cached query may want something that the subscription hasn't returned yet
 30 |     subState = entities[typeName] && entities[typeName][docId] || {[context.idFieldName]: ''};
 31 |     parentTypeSchema = context.schema.types[typeName];
 32 |   }
 33 |   // default to subState for denorming the persisted store subscriptions
 34 |   const fields = reqAST ? reqAST.selectionSet.selections : Object.keys(subState);
 35 |   for (let i = 0; i < fields.length; i++) {
 36 |     const field = fields[i];
 37 |     if (!reqAST) {
 38 |       // we're mocking data from a sub
 39 |       // TODO recursively denormalize & exit early if not found
 40 |       reduction[field] = subState[field];
 41 |       continue;
 42 |     }
 43 |     if (field.kind === INLINE_FRAGMENT) {
 44 |       // TODO handle null typeCondition?
 45 |       if (field.typeCondition.name.value === parentTypeSchema.name) {
 46 |         // only follow through if it's the correct union subtype
 47 |         visitObject(subState, field, parentTypeSchema, context, reduction);
 48 |       }
 49 |       continue;
 50 |     }
 51 |     const fieldName = field.name.value;
 52 |     const aliasOrFieldName = field.alias && field.alias.value || fieldName;
 53 |     if (field.name.value === TYPENAME) {
 54 |       reduction[aliasOrFieldName] = parentTypeSchema.name;
 55 |     } else {
 56 |       const cachedDirective = field.directives && field.directives.find(d => d.name.value === CACHED);
 57 | 
 58 |       if (cachedDirective) {
 59 |         const cachedDirectiveArgs = makeCachedArgs(cachedDirective.arguments, context.variables, context.schema);
 60 |         const {type} = parseCachedType(cachedDirectiveArgs.type);
 61 |         const typeSchema = context.schema.types[type];
 62 |         const fieldState = getCachedFieldState(subState, cachedDirectiveArgs, field, context);
 63 |         if (Array.isArray(fieldState)) {
 64 |           reduction[aliasOrFieldName] = visitIterable(fieldState, field, typeSchema, context, aliasOrFieldName);
 65 |         } else {
 66 |           reduction[aliasOrFieldName] = visitObject(fieldState, field, typeSchema, context);
 67 |         }
 68 |         continue;
 69 |       }
 70 |       const fieldSchema = getFieldSchema(field, parentTypeSchema, context.schema);
 71 |       const nnFieldType = ensureTypeFromNonNull(fieldSchema.type);
 72 | 
 73 |       const hasData = subState.hasOwnProperty(fieldName);
 74 |       if (hasData || isLive(field.directives)) {
 75 |         const fieldState = maybeLiveQuery(subState, fieldSchema, field, nnFieldType, context);
 76 |         const rootFieldType = ensureRootType(nnFieldType);
 77 |         const typeSchema = context.schema.types[rootFieldType.name];
 78 |         if (isPrimitive(nnFieldType.kind) || subState[fieldName] === null) {
 79 |           reduction[aliasOrFieldName] = visitScalar(fieldState, context.coerceTypes[typeSchema.name])
 80 |         } else {
 81 |           if ((nnFieldType.kind === LIST)) {
 82 |             if (fieldState) {
 83 |               reduction[aliasOrFieldName] = visitIterable(fieldState, field, typeSchema, context, aliasOrFieldName);
 84 |             } else {
 85 |               reduction[aliasOrFieldName] = [visitObject(fieldState, field, typeSchema, context)];
 86 |             }
 87 |           } else {
 88 |             reduction[aliasOrFieldName] = visitObject(fieldState, field, typeSchema, context);
 89 |           }
 90 |         }
 91 |       } else {
 92 |         reduction[aliasOrFieldName] = handleMissingData(visitObject, field, nnFieldType, cachedDirective, context);
 93 |       }
 94 |     }
 95 |   }
 96 |   if (reqAST && fields) {
 97 |     calculateSendToServer(reqAST, context.idFieldName)
 98 |   }
 99 |   return reduction;
100 | };
101 | 
102 | const visitIterable = (subState, reqAST, typeSchema, context, aliasOrFieldName) => {
103 |   // for each value in the array, get the denormalized item
104 |   let mappedState = [];
105 |   // the array could be a bunch of objects, or primitives
106 |   const loopFunc = isPrimitive(typeSchema.kind) ?
107 |     res => visitScalar(res, context.coerceTypes[typeSchema.name]) :
108 |     res => visitObject(res, reqAST, typeSchema, context);
109 | 
110 |   for (let i = 0; i < subState.length; i++) {
111 |     mappedState[i] = loopFunc(subState[i]);
112 |   }
113 | 
114 |   // copy over metadata for smart pagination
115 |   for (let i = 0; i < arrayMetadata.length; i++) {
116 |     const metadataName = arrayMetadata[i];
117 |     if (subState[metadataName]) {
118 |       mappedState[metadataName] = subState[metadataName];
119 |     }
120 |   }
121 | 
122 |   const {sort, filter} = context;
123 |   const sortFn = sort && sort[aliasOrFieldName];
124 |   const filterFn = filter && filter[aliasOrFieldName];
125 |   if (filterFn) {
126 |     mappedState = mappedState.filter(filterFn);
127 |   }
128 |   if (sortFn) {
129 |     mappedState = mappedState.sort(sortFn);
130 |   }
131 |   return mappedState;
132 | };
133 | 
134 | const visitScalar = (subState, coercion) => {
135 |   return coercion ? coercion(subState) : subState;
136 | };
137 | 
138 | export default function denormalizeStore(context) {
139 |   const {getState, schema: {querySchema}, operation, normalizedResult} = context;
140 |   if (normalizedResult) {
141 |     // this is for rehydrating subscriptions
142 |     const visitor = Array.isArray(normalizedResult) ? visitIterable : visitObject;
143 |     return visitor(normalizedResult, null, {}, context);
144 |   }
145 |   return visitObject(getState().result, operation, querySchema, context);
146 | };
147 | 


--------------------------------------------------------------------------------
/src/normalize/duck.js:
--------------------------------------------------------------------------------
 1 | import mergeStores from './mergeStores';
 2 | 
 3 | export const ADD_SUBSCRIPTION = '@@cashay/ADD_SUBSCRIPTION';
 4 | export const UPDATE_SUBSCRIPTION = '@@cashay/UPDATE_SUBSCRIPTION';
 5 | export const REMOVE_SUBSCRIPTION = '@@cashay/REMOVE_SUBSCRIPTION';
 6 | export const INSERT_QUERY = '@@cashay/INSERT_QUERY';
 7 | export const INSERT_MUTATION = '@@cashay/INSERT_MUTATION';
 8 | export const SET_VARIABLES = '@@cashay/SET_VARIABLES';
 9 | export const SET_ERROR = '@@cashay/SET_ERROR';
10 | export const SET_STATUS = '@@cashay/SET_STATUS';
11 | export const CLEAR = '@@cashay/CLEAR';
12 | 
13 | const initialState = {
14 |   entities: {
15 |     // [GraphQLObjectTypeName] : {
16 |     //   [args?]: Array.isArray(GraphQLObjectType) ? {
17 |     //     [FRONT]: [],
18 |     //     [BACK]: [],
19 |     //     [FULL]: [],
20 |     //   } : {}
21 |     // }
22 |   },
23 |   error: null,
24 |   ops: {
25 |     // [op]: {
26 |     //   [key]: {
27 |     //     variables: {},
28 |     //     status: '',
29 |     //     error: {}
30 |     //   }
31 |     // }
32 |   },
33 |   result: {}
34 | };
35 | 
36 | export default function reducer(state = initialState, action) {
37 |   const {type} = action;
38 |   if (type.startsWith('@@cashay')) {
39 |     if (type === CLEAR) return initialState;
40 |     const isMutation = type === INSERT_MUTATION;
41 |     return mergeStores(state, action.payload, isMutation);
42 |   } else {
43 |     return state;
44 |   }
45 | };
46 | 


--------------------------------------------------------------------------------
/src/normalize/getCachedFieldState.js:
--------------------------------------------------------------------------------
  1 | import {parseCachedType, NORM_DELIMITER} from '../utils';
  2 | import {TypeKind} from 'graphql/type/introspection';
  3 | 
  4 | const {UNION} = TypeKind;
  5 | 
  6 | const stringifyEntity = (type, id) => `${type}${NORM_DELIMITER}${id}`;
  7 | 
  8 | const makeDefaultResolver = (id, idFieldName) => {
  9 |   if (Array.isArray(id)) {
 10 |     return (doc) => id.includes(doc[idFieldName])
 11 |   } else {
 12 |     return (doc) => doc[idFieldName] === id;
 13 |   }
 14 | };
 15 | 
 16 | const initCachedDeps = (cachedDeps, types, queryDep, resolver) => {
 17 |   // uses types in the event of a union
 18 |   for (let i = 0; i < types.length; i++) {
 19 |     const type = types[i];
 20 |     cachedDeps[type] = cachedDeps[type] || {};
 21 |     cachedDeps[type][queryDep] = cachedDeps[type][queryDep] || new Set();
 22 |     cachedDeps[type][queryDep].add(resolver);
 23 |   }
 24 | };
 25 | 
 26 | const resolveFromState = (resolver, possibleTypes, isArray, entities) => {
 27 |   const result = isArray ? [] : {};
 28 |   for (let t = 0; t < possibleTypes.length; t++) {
 29 |     const type = possibleTypes[t];
 30 |     const typeEntities = entities[type];
 31 |     if (!typeEntities) continue;
 32 |     const docIds = Object.keys(typeEntities);
 33 |     for (let i = 0; i < docIds.length; i++) {
 34 |       const docId = docIds[i];
 35 |       const doc = typeEntities[docId];
 36 |       if (resolver(doc)) {
 37 |         const stringifiedDoc = stringifyEntity(type, docId);
 38 |         if (isArray) {
 39 |           result.push(stringifiedDoc);
 40 |         } else {
 41 |           return stringifiedDoc;
 42 |         }
 43 |       }
 44 |     }
 45 |   }
 46 |   // if not everything loaded & we just wanted 1, we want to return an object
 47 |   return result;
 48 | };
 49 | 
 50 | 
 51 | export default function getCachedFieldState(source, cachedDirectiveArgs, field, context) {
 52 |   const {cachedDeps, resolveCached, getState, idFieldName, queryDep} = context;
 53 |   const {type, typeIsList} = parseCachedType(cachedDirectiveArgs.type);
 54 |   const typeSchema = context.schema.types[type];
 55 |   const isUnion = typeSchema.kind === UNION;
 56 |   const possibleTypes = isUnion ? Object.keys(typeSchema.possibleTypes) : [type];
 57 |   const {entities} = getState();
 58 |   const aliasOrFieldName = field.alias && field.alias.value || field.name.value;
 59 |   const cacheResolverFactory = resolveCached && resolveCached[aliasOrFieldName];
 60 |   const resolver = cacheResolverFactory && cacheResolverFactory(source, cachedDirectiveArgs);
 61 | 
 62 |   if (isUnion && typeof resolver !== 'function') {
 63 |     throw new Error(`@cached requires resolveCached to return a function for union types.`);
 64 |   }
 65 | 
 66 |   // standard resolver function that completes in O(n) time for n docs in the state[type]
 67 |   if (typeof resolver === 'function') {
 68 |     initCachedDeps(cachedDeps, possibleTypes, queryDep, resolver);
 69 |     return resolveFromState(resolver, possibleTypes, typeIsList, entities);
 70 |   }
 71 | 
 72 |   // no factory means we need to make a default one based off of id/ids.
 73 |   // use resolveCached because they could just return something falsy
 74 |   if (!cacheResolverFactory) {
 75 |     const {id, ids} = cachedDirectiveArgs;
 76 |     if (!id && !ids) {
 77 |       throw new Error(`Must supply either id, ids or resolveCached for ${aliasOrFieldName}`);
 78 |     }
 79 |     const idLookup = ids || id;
 80 |     const isArray = idLookup === ids;
 81 |     if (isArray !== typeIsList) {
 82 |       const reqArg = typeIsList ? 'ids' : 'id';
 83 |       throw new Error(`Type ${cachedDirectiveArgs.type} requires a 'resolveCached' or the '${reqArg} arg`);
 84 |     }
 85 |     const depResolver = makeDefaultResolver(idLookup, idFieldName);
 86 |     initCachedDeps(cachedDeps, possibleTypes, queryDep, depResolver);
 87 |     return isArray ? ids.map(id => stringifyEntity(type, id)) : stringifyEntity(type, id);
 88 |   }
 89 | 
 90 |   const depResolver = makeDefaultResolver(resolver, idFieldName);
 91 |   // a resolver that looks for a single document
 92 |   if (typeof resolver === 'string') {
 93 |     if (typeIsList) {
 94 |       throw new Error(`Type ${cachedDirectiveArgs.type} requires your resolveCached to return a single id`)
 95 |     }
 96 |     initCachedDeps(cachedDeps, possibleTypes, queryDep, depResolver);
 97 |     return stringifyEntity(type, resolver);
 98 |   }
 99 | 
100 |   // a resolver that looks for a series of documents
101 |   if (Array.isArray(resolver)) {
102 |     if (!typeIsList) {
103 |       throw new Error(`Type ${cachedDirectiveArgs.type} requires your resolveCached to return an array`)
104 |     }
105 |     initCachedDeps(cachedDeps, possibleTypes, queryDep, depResolver);
106 |     return resolver.map(id => stringifyEntity(type, id));
107 |   }
108 |   return {};
109 | };
110 | 


--------------------------------------------------------------------------------
/src/normalize/getFieldState.js:
--------------------------------------------------------------------------------
  1 | import {STRING, INT} from 'graphql/language/kinds';
  2 | import {isObject, getRegularArgsKey, FULL, FRONT, BACK} from '../utils';
  3 | import separateArgs from './separateArgs';
  4 | import {splitNormalString, sendChildrenToServer} from './denormalizeHelpers';
  5 | import {RequestArgument} from '../helperClasses';
  6 | 
  7 | /**
  8 |  * given a parent field state & some args, drill down to the data using the args as a map
  9 |  *
 10 |  * @param {object} fieldState the parent field in the redux state.
 11 |  * @param {object} fieldSchema the portion of the clientSchema relating to the fieldState
 12 |  * @param {object} selection the original query AST that holds the arguments
 13 |  * @param {object} context
 14 |  *
 15 |  * @returns {*} an object, or array, or scalar from the normalized store
 16 |  * */
 17 | export default function getFieldState(fieldState, fieldSchema, selection, context) {
 18 |   if (!isObject(fieldState) || !fieldSchema.args) return fieldState;
 19 |   const {arguments: fieldArgs} = selection;
 20 |   // TODO can we short circuit if there are no fieldArgs provided?
 21 |   // if (!fieldArgs) return fieldState;
 22 |   let subState = fieldState;
 23 |   const {skipTransform, paginationWords, variables} = context;
 24 |   const {regularArgs, paginationArgs} = separateArgs(fieldSchema, fieldArgs, paginationWords, variables);
 25 |   if (regularArgs) {
 26 |     const regularArgsString = getRegularArgsKey(regularArgs);
 27 |     subState = subState[regularArgsString];
 28 |   }
 29 |   if (paginationArgs) {
 30 |     const arrType = subState[FULL] ? FULL : paginationArgs[paginationWords.last] !== undefined ? BACK : FRONT;
 31 |     subState = handlePaginationArgs(paginationArgs, subState[arrType]);
 32 | 
 33 |     // reduce the ask from the server
 34 |     if (arrType !== FULL && !skipTransform) {
 35 |       reducePaginationRequest(paginationArgs, subState, fieldSchema, selection, context);
 36 |     }
 37 |   }
 38 |   return subState;
 39 | };
 40 | 
 41 | /**
 42 |  * Provide a subset of the array of documents in the state
 43 |  * @param {Object} paginationArgs an object with only 1 field: FIRST or LAST
 44 |  * @param {Array} usefulArray the array of document corresponding to the FIRST or LAST
 45 |  * */
 46 | const handlePaginationArgs = (paginationArgs, usefulArray) => {
 47 |   const {first, last} = paginationArgs;
 48 | 
 49 |   // try to use the full array. if it doesn't exist, see if we're going backwards & use the back array, else front
 50 |   const count = last !== undefined ? last : first;
 51 | 
 52 |   // if last is provided, then first is not and we need to go from last to first
 53 |   let slicedArr;
 54 |   if (last) {
 55 |     const firstNonNullIdx = countLeftPadding(usefulArray);
 56 |     const firstDesiredDocIdx = usefulArray.length - last;
 57 |     const startIdx = Math.max(firstNonNullIdx, firstDesiredDocIdx);
 58 |     slicedArr = usefulArray.slice(startIdx, usefulArray.length);
 59 |   } else {
 60 |     const lastNonNullIdx = countRightPadding(usefulArray);
 61 |     const lastDesiredDocIdx = first - 1;
 62 |     const sliceThrough = Math.min(lastNonNullIdx, lastDesiredDocIdx);
 63 |     slicedArr = usefulArray.slice(0, sliceThrough + 1);
 64 |   }
 65 | 
 66 |   // assign BOF and EOF to the array, similar to hasPreviousPage, hasNextPage
 67 |   assignFieldStateMeta(slicedArr, usefulArray, count);
 68 |   return slicedArr;
 69 | };
 70 | 
 71 | const reducePaginationRequest = (paginationArgs, usefulArray, fieldSchema, selection, context) => {
 72 |   const {first, last} = paginationArgs;
 73 |   const count = last || first;
 74 |   const {arguments: fieldArgs} = selection;
 75 |   const {paginationWords} = context;
 76 |   const countWord = last !== undefined ? paginationWords.last : paginationWords.first;
 77 | 
 78 |   const missingDocCount = count - usefulArray.length;
 79 |   // if we have a partial response & the backend accepts a cursor, only ask for the missing pieces
 80 |   if (missingDocCount > 0 && missingDocCount < count) {
 81 |     const cursorWord = last ? paginationWords.before : paginationWords.after;
 82 |     if (!fieldSchema.args[cursorWord]) {
 83 |       throw new Error(`Your schema does not accept an argument for your cursor named ${cursorWord}.`);
 84 |     }
 85 |     // flag all AST children with sendToServer = true
 86 |     // TODO write test to make sure I don't need to send children to server
 87 |     // sendChildrenToServer(selection);
 88 |     // TODO when to remove doWarn?
 89 |     const doWarn = true;
 90 |     const cashayState = context.getState();
 91 |     const {bestCursor, cursorIdx} = getBestCursor(first, usefulArray, cashayState.entities, doWarn);
 92 |     const desiredDocCount = count - (cursorIdx + 1);
 93 | 
 94 |     // save the original arguments, we'll overwrite them with efficient ones for the server,
 95 |     // but need them later to create the denormaliezd response
 96 |     selection.originalArguments = fieldArgs.slice();
 97 | 
 98 |     //get the index of the count argument so we can replace it with the new one
 99 |     const countArgIdx = fieldArgs.findIndex(arg => arg.name.value === countWord);
100 | 
101 |     //  create a new count arg & override the old one
102 |     fieldArgs[countArgIdx] = makeCountArg(countWord, desiredDocCount);
103 | 
104 |     // make a new cursor argument
105 |     const newCursorArg = makeCursorArg(cursorWord, bestCursor);
106 |     fieldArgs.push(newCursorArg);
107 |   }
108 | };
109 | 
110 | const getBestCursor = (first, usefulArray, entities, doWarn) => {
111 |   let storedDoc;
112 |   let i;
113 |   if (first) {
114 |     for (i = usefulArray.length - 1; i >= 0; i--) {
115 |       // given something like `Post:123`, return the document from the store
116 |       const [typeName, docId] = splitNormalString(usefulArray[i]);
117 |       storedDoc = entities[typeName][docId];
118 |       if (storedDoc.cursor !== undefined) break;
119 |     }
120 |   } else {
121 |     for (i = 0; i < usefulArray.length; i++) {
122 |       const [typeName, docId] = splitNormalString(usefulArray[i]);
123 |       storedDoc = entities[typeName][docId];
124 |       if (storedDoc.cursor !== undefined) break;
125 |     }
126 |   }
127 | 
128 |   // TODO this is incorrect, I think it should be length -1 and break this into 2 functions
129 |   if (i >= 0 && i < usefulArray.length) {
130 |     return {bestCursor: storedDoc.cursor, cursorIdx: i};
131 |   } else if (doWarn) {
132 |     console.warn(`No cursor was included for the following docs: ${usefulArray}. 
133 |         Include the 'cursor' field for those docs`)
134 |   }
135 | };
136 | 
137 | const countLeftPadding = array => {
138 |   for (let i = 0; i < array.length; i++) {
139 |     if (array[i]) {
140 |       return i;
141 |     }
142 |   }
143 | };
144 | 
145 | const countRightPadding = array => {
146 |   for (let i = array.length - 1; i >= 0; i--) {
147 |     if (array[i]) {
148 |       return i;
149 |     }
150 |   }
151 | };
152 | 
153 | /**
154 |  * Assign metadata to the array.
155 |  * The EOF, BOF are useful to the front-end developer if they want to know if there are more docs available
156 |  * The count is useful internally to mutations so we know how a certain query has been mutated
157 |  * @param {Array} slicedArray the subset of the usefulArray
158 |  * @param {Array} usefulArray all the documents in that direction that are available on the client
159 |  * @param {Number} count the number of documents desired by the front-end
160 |  * */
161 | const assignFieldStateMeta = (slicedArray, usefulArray, count) => {
162 |   Object.assign(slicedArray, {
163 |     EOF: slicedArray[slicedArray.length - 1] === usefulArray[usefulArray.length - 1],
164 |     BOF: slicedArray[0] === usefulArray[0],
165 |     count
166 |   });
167 | };
168 | 
169 | const makeCursorArg = (cursorName, cursorValue) => new RequestArgument(cursorName, STRING, cursorValue);
170 | const makeCountArg = (countName, countValue) => new RequestArgument(countName, INT, countValue);
171 | 


--------------------------------------------------------------------------------
/src/normalize/getSubReqAST.js:
--------------------------------------------------------------------------------
 1 | import {INLINE_FRAGMENT} from 'graphql/language/kinds';
 2 | 
 3 | export const getSubReqAST = (key, reqAST, unionType) => {
 4 |   let subReqAST;
 5 |   const fields = reqAST.selectionSet.selections;
 6 |   for (let i = 0; i < fields.length; i++) {
 7 |     const field = fields[i];
 8 |     if (field.kind === INLINE_FRAGMENT) {
 9 |       if (field.typeCondition.name.value !== unionType) continue;
10 |       subReqAST = getSubReqAST(key, field);
11 |     } else {
12 |       const aliasOrFieldName = field.alias && field.alias.value || field.name.value;
13 |       if (aliasOrFieldName === key) {
14 |         subReqAST = field;
15 |       }
16 |     }
17 |     if (subReqAST) {
18 |       return subReqAST;
19 |     }
20 |   }
21 |   throw new Error(`${key} was found in the query response, but not the request.
22 |     Did you optimistically add more fields than you originally requested?`)
23 | };
24 | 


--------------------------------------------------------------------------------
/src/normalize/mergeStores.js:
--------------------------------------------------------------------------------
  1 | import {isObject, FRONT, BACK, FULL, REMOVAL_FLAG} from '../utils';
  2 | 
  3 | const paginationArrayNames = new Set([FRONT, BACK, FULL]);
  4 | 
  5 | /**
  6 |  * check for overlap in docs, intelligently append keys
  7 |  * all the logic in here is to mitigate the problems with cursor-based pagination (duplicates, etc)
  8 |  * pagination should never have the same document twice
  9 |  * the question is, do we maintain the old order, or the new?
 10 |  * maintaining the old order ensures less jumping around & that the user won't have to scroll past the same thing twice
 11 |  * so if the new stuff has references to old stuff, delete em
 12 |  * then, stick em on the end
 13 |  */
 14 | const mergeSameArrays = (targetArray, srcArray, isAppend) => {
 15 |   const srcSet = new Set(srcArray);
 16 |   for (let entry of targetArray) {
 17 |     srcSet.delete(entry);
 18 |   }
 19 |   const reducedSrcArr = [...srcSet];
 20 |   return isAppend ? targetArray.concat(reducedSrcArr) : reducedSrcArr.concat(targetArray);
 21 | };
 22 | 
 23 | /**
 24 |  * merging front and back is a little volatile because per mergeSameArrays, we keep the original order
 25 |  * it's possible, for example, for a post to get downvoted to hell, causing it to first appear in the front
 26 |  * but then later in the back. such is a pitfall of cursor-based arrays
 27 |  */
 28 | const mergeDifferentArrays = (front, back) => {
 29 |   const frontSet = new Set(front);
 30 |   let isComplete = false;
 31 |   for (let i = 0; i < back.length; i++) {
 32 |     const entry = back[i];
 33 |     if (frontSet.has(entry)) {
 34 |       isComplete = true;
 35 |       frontSet.delete(entry);
 36 |     }
 37 |   }
 38 |   if (isComplete) {
 39 |     const reducedFront = [...frontSet];
 40 |     return reducedFront.concat(back);
 41 |   }
 42 | };
 43 | 
 44 | /**
 45 |  * An exercise in combinatorics.
 46 |  * Specific logic on how to merge arrays
 47 |  * Many of these are edge cases, like merging a paginated array with a full array
 48 |  * */
 49 | const handleArrays = (target, src) => {
 50 |   // merge similar
 51 |   const pageTarget = {};
 52 |   const pageSrc = {};
 53 |   for (let arrType of paginationArrayNames) {
 54 |     pageTarget[arrType] = Array.isArray(target[arrType]);
 55 |     pageSrc[arrType] = Array.isArray(src[arrType]);
 56 |   }
 57 |   if (pageTarget[FULL]) {
 58 |     if (pageSrc[FULL]) {
 59 |       target[FULL] = mergeSameArrays(target[FULL], src[FULL], true);
 60 |     } else if (pageSrc[FRONT]) {
 61 |       target[FULL] = mergeSameArrays(target[FULL], src[FRONT], false);
 62 |     } else if (pageSrc[BACK]) {
 63 |       target[FULL] = mergeSameArrays(target[FULL], src[BACK], true);
 64 |     }
 65 |   } else {
 66 |     if (pageSrc[FULL]) {
 67 |       target[FULL] = src[FULL];
 68 |     } else {
 69 |       if (pageTarget[FRONT] && pageSrc[FRONT]) {
 70 |         const targetArr = src[FRONT].EOF ? FULL : FRONT;
 71 |         target[targetArr] = mergeSameArrays(target[FRONT], src[FRONT], true);
 72 |       }
 73 |       if (pageTarget[BACK] && pageSrc[BACK]) {
 74 |         const targetArr = src[BACK].BOF ? FULL : BACK;
 75 |         target[targetArr] = mergeSameArrays(target[BACK], src[BACK], false);
 76 |       }
 77 |     }
 78 |   }
 79 | 
 80 |   if (!target[FRONT] && src[FRONT]) {
 81 |     target[FRONT] = src[FRONT];
 82 |   }
 83 |   if (!target[BACK] && src[BACK]) {
 84 |     target[BACK] = src[BACK];
 85 |   }
 86 | 
 87 |   // check to see if target has all the docs (but only if we got something new recently)
 88 |   if (target[FRONT] && target[BACK] && (src[FRONT] || src[BACK])) {
 89 |     const full = mergeDifferentArrays(target[FRONT], target[BACK]);
 90 |     if (full) {
 91 |       target[FULL] = full;
 92 |     }
 93 |   }
 94 |   if (target[FULL]) {
 95 |     delete target[FRONT];
 96 |     delete target[BACK];
 97 |   }
 98 | };
 99 | 
100 | /**
101 |  * A cashay array is an object that holds up to 2 arrays:
102 |  * either full (not paginated) or front and/or back
103 |  * */
104 | const detectCashayArray = (src, allSrcKeys) => {
105 |   if (allSrcKeys.length < 1 || allSrcKeys.length > 2) return false;
106 |   for (let i = 0; i < allSrcKeys.length; i++) {
107 |     const srcKey = allSrcKeys[i];
108 |     if (!paginationArrayNames.has(srcKey) || !Array.isArray(src[srcKey])) {
109 |       return false;
110 |     }
111 |   }
112 |   return true;
113 | };
114 | 
115 | /**
116 |  * A deep merge that has exclusive logic for merging arrays suitable for pagination
117 |  * */
118 | export default function mergeStores(state, src, isMutation) {
119 |   // first shallow copy the state as a simple way to get the primitives, we'll later overwrite the pointers
120 |   if (!src) return state;
121 |   const target = {...state};
122 |   const srcKeys = Object.keys(src);
123 |   const isCashayArray = detectCashayArray(src, srcKeys);
124 |   if (isCashayArray && !isMutation) {
125 |     handleArrays(target, src)
126 |   } else {
127 |     for (let i = 0; i < srcKeys.length; i++) {
128 |       const key = srcKeys[i];
129 |       const srcProp = src[key];
130 |       const targetProp = target[key];
131 |       if (isObject(srcProp) && isObject(targetProp) && !(srcProp instanceof Date)) {
132 |         const srcIsArray = Array.isArray(srcProp);
133 |         const stateIsArray = Array.isArray(targetProp);
134 |         if (!srcIsArray && !stateIsArray) {
135 |           // if both the state and src are objects, merge them
136 |           target[key] = {...mergeStores(targetProp, srcProp, isMutation)};
137 |         } else if (isCashayArray) {
138 |           // this is a mutation, so the array length
139 |           if (key === FRONT) {
140 |             target[key] = [...targetProp.slice(0, srcProp.count), ...srcProp.slice()];
141 |           } else if (key === BACK) {
142 |             const spliceStart = targetProp.length - srcProp.count;
143 |             target[key] = [...targetProp.slice(spliceStart), ...srcProp]
144 |           }
145 |         } else {
146 |           // for 2 arrays that aren't cashay arrays, use a simple replace (can extend in the future)
147 |           target[key] = srcProp;
148 |         }
149 |       } else {
150 |         if (srcProp === REMOVAL_FLAG) {
151 |           delete target[key];
152 |         } else {
153 |           // if there is a disagreement on the type of value, default to using the src
154 |           target[key] = srcProp;
155 |         }
156 | 
157 |       }
158 |     }
159 |   }
160 |   return target;
161 | };
162 | 


--------------------------------------------------------------------------------
/src/normalize/normalizeResponse.js:
--------------------------------------------------------------------------------
  1 | import mergeStores from './mergeStores';
  2 | import separateArgs from './separateArgs';
  3 | import {getSubReqAST} from './getSubReqAST';
  4 | import {
  5 |   ensureRootType,
  6 |   CACHED,
  7 |   getRegularArgsKey,
  8 |   isObject,
  9 |   getFieldSchema,
 10 |   NORM_DELIMITER,
 11 |   FULL,
 12 |   FRONT,
 13 |   BACK,
 14 |   TYPENAME,
 15 |   getVariableValue,
 16 |   parseCachedType
 17 | } from '../utils';
 18 | import {VARIABLE} from 'graphql/language/kinds';
 19 | import {TypeKind} from 'graphql/type/introspection';
 20 | 
 21 | const {UNION} = TypeKind;
 22 | 
 23 | const mapResponseToResult = (nestedResult, response, fieldSchema, reqASTArgs, context) => {
 24 |   if (!fieldSchema.args) return response;
 25 |   const {paginationWords, variables} = context;
 26 |   const {regularArgs, paginationArgs} = separateArgs(fieldSchema, reqASTArgs, paginationWords, variables);
 27 |   if (paginationArgs) {
 28 |     const {first, last} = paginationArgs;
 29 |     const arrName = first !== undefined ? FRONT : last !== undefined ? BACK : FULL;
 30 |     response = {[arrName]: response};
 31 |   }
 32 |   if (regularArgs === false) {
 33 |     return response;
 34 |   } else {
 35 |     const regularArgsString = getRegularArgsKey(regularArgs);
 36 |     const resultObj = {[regularArgsString]: response};
 37 |     return (isObject(nestedResult) && !Array.isArray(nestedResult)) ? mergeStores(nestedResult, resultObj) : resultObj;
 38 |   }
 39 | };
 40 | 
 41 | const visitObject = (bag, subResponse, reqAST, subSchema, context) => {
 42 |   const keys = Object.keys(subResponse);
 43 |   const reduction = {};
 44 |   const typenameField = reqAST && reqAST.selectionSet.selections.find(field => field.name.value === TYPENAME);
 45 |   const typenameAlias = typenameField && typenameField.alias && typenameField.alias.value || TYPENAME;
 46 |   for (let i = 0; i < keys.length; i++) {
 47 |     const key = keys[i];
 48 |     if (key === typenameAlias) continue;
 49 |     if (reqAST) {
 50 |       const subReqAST = getSubReqAST(key, reqAST, subResponse[typenameAlias]);
 51 |       const name = subReqAST.name.value;
 52 |       const cachedDirective = subReqAST.directives.find(d => d.name.value === CACHED);
 53 |       if (cachedDirective) {
 54 |         const typeArg = cachedDirective.arguments.find(arg => arg.name.value === 'type');
 55 |         const typeName = getVariableValue(typeArg, context.variables);
 56 |         const {type} = parseCachedType(typeName);
 57 |         const typeSchema = context.schema.types[type];
 58 |         visit(bag, subResponse[key], subReqAST, typeSchema, context);
 59 |       } else {
 60 |         const fieldSchema = getFieldSchema(subReqAST, subSchema, context.schema);
 61 |         const fieldType = ensureRootType(fieldSchema.type);
 62 |         // handle first recursion where things are stored in the query (sloppy)
 63 |         const typeSchema = context.schema.types[fieldType.name] || subSchema.types[fieldType.name];
 64 |         const normalizedResponse = visit(bag, subResponse[key], subReqAST, typeSchema, context);
 65 |         reduction[name] = mapResponseToResult(reduction[name], normalizedResponse, fieldSchema, subReqAST.arguments, context);
 66 |       }
 67 |     } else {
 68 |       // this is for subscriptions, since we don't explicitly have a request AST
 69 |       const fieldSchema = subSchema.fields[key];
 70 |       const fieldType = ensureRootType(fieldSchema.type);
 71 |       const typeSchema = context.schema.types[fieldType.name];
 72 |       reduction[key] = visit(bag, subResponse[key], undefined, typeSchema, context);
 73 |     }
 74 |   }
 75 |   return reduction;
 76 | };
 77 | const visitEntity = (bag, subResponse, reqAST, subSchema, context, id) => {
 78 |   const entityKey = subSchema.name;
 79 |   bag[entityKey] = bag[entityKey] || {};
 80 |   bag[entityKey][id] = bag[entityKey][id] || {};
 81 |   let normalized = visitObject(bag, subResponse, reqAST, subSchema, context);
 82 |   bag[entityKey][id] = mergeStores(bag[entityKey][id], normalized);
 83 |   return `${entityKey}${NORM_DELIMITER}${id}`;
 84 | };
 85 | 
 86 | const visitIterable = (bag, subResponse, reqAST, subSchema, context) => {
 87 |   const normalizedSubResponse = subResponse.map(res => visit(bag, res, reqAST, subSchema, context));
 88 |   if (reqAST && reqAST.arguments && reqAST.arguments.length) {
 89 |     const {first, last} = context.paginationWords;
 90 |     const paginationFlags = [{word: first, flag: 'EOF'}, {word: last, flag: 'BOF'}];
 91 |     for (let i = 0; i < paginationFlags.length; i++) {
 92 |       const {word, flag} = paginationFlags[i];
 93 |       const count = reqAST.arguments.find(arg => arg.name.value === word);
 94 |       // allow count === 0
 95 |       if (count !== undefined) {
 96 |         let countVal;
 97 |         if (count.value.kind === VARIABLE) {
 98 |           const variableDefName = count.value.name.value;
 99 |           countVal = +context.variables[variableDefName];
100 | 
101 |           // pass the count onto the normalized response to perform a slice during the state merge
102 |           normalizedSubResponse.count = subResponse.count;
103 | 
104 |           // MUTATES CONTEXT VARIABLES. update the difference in the variables (passed on to redux state)
105 |           context.variables[variableDefName] = subResponse.length;
106 | 
107 |           // MUTATES ORIGINAL DENORMALIZED RESPONSE. kinda ugly, but saves an additional tree walk.
108 |           subResponse.count = subResponse.length;
109 | 
110 |         } else {
111 |           countVal = +count.value.value;
112 |         }
113 |         if (normalizedSubResponse.length < countVal) {
114 |           normalizedSubResponse[flag] = true;
115 |         }
116 |         break;
117 |       }
118 |     }
119 |   }
120 |   return normalizedSubResponse
121 | };
122 | 
123 | const visitUnion = (bag, subResponse, reqAST, subSchema, context) => {
124 |   const typenameField = reqAST.selectionSet.selections.find(field => field.name.value === TYPENAME);
125 |   const typenameAlias = typenameField.alias && typenameField.alias.value || TYPENAME;
126 |   const concreteSubScema = context.schema.types[subResponse[typenameAlias]];
127 |   return visit(bag, subResponse, reqAST, concreteSubScema, context);
128 | };
129 | 
130 | const visit = (bag, subResponse, reqAST, subSchema, context) => {
131 |   if (!isObject(subResponse) || subResponse instanceof Date) {
132 |     return subResponse;
133 |   }
134 |   if (Array.isArray(subResponse)) {
135 |     return visitIterable(bag, subResponse, reqAST, subSchema, context);
136 |   }
137 |   if (subSchema.kind === UNION) {
138 |     return visitUnion(bag, subResponse, reqAST, subSchema, context);
139 |   }
140 |   const {idFieldName} = context;
141 |   if (subSchema.fields[idFieldName]) {
142 |     const id = subResponse[idFieldName];
143 |     return visitEntity(bag, subResponse, reqAST, subSchema, context, id);
144 |   }
145 |   return visitObject(bag, subResponse, reqAST, subSchema, context);
146 | 
147 | };
148 | 
149 | export default (response, context, isSubscription) => {
150 |   const entities = {};
151 |   let result;
152 |   if (isSubscription) {
153 |     result = visitEntity(entities, response, null, context.typeSchema, context, response[context.idFieldName]);
154 |   } else {
155 |     result = visitObject(entities, response, context.operation, context.schema.querySchema, context);
156 |   }
157 |   return {
158 |     entities,
159 |     result
160 |   };
161 | };
162 | 


--------------------------------------------------------------------------------
/src/normalize/separateArgs.js:
--------------------------------------------------------------------------------
 1 | import {VARIABLE} from 'graphql/language/kinds';
 2 | import {TypeKind} from 'graphql/type/introspection';
 3 | import {ensureTypeFromNonNull, getVariableValue, BEFORE, AFTER} from '../utils';
 4 | 
 5 | const {LIST} = TypeKind;
 6 | 
 7 | const acceptsArgs = (fieldSchema, paginationWords, paginationWordKeys) => {
 8 |   let acceptsPaginationArgs = false;
 9 |   let acceptsRegularArgs = false;
10 |   for (let i = 0; i < paginationWordKeys.length; i++) {
11 |     const key = paginationWordKeys[i];
12 |     const pageWord = paginationWords[key];
13 |     if (fieldSchema.args[pageWord]) {
14 |       acceptsPaginationArgs = true;
15 |     } else {
16 |       acceptsRegularArgs = true;
17 |     }
18 |   }
19 |   return {acceptsPaginationArgs, acceptsRegularArgs};
20 | };
21 | /**
22 |  * Determine whether the arguments provided are going to be used for pagination
23 |  * @param {Object} fieldSchema a piece of the GraphQL client schema for the particular field
24 |  * @param {Array} reqASTArgs the arguments coming from the request AST
25 |  * @param {Object} paginationWords an object containing the 4 pagination meanings & the user-defined words they use
26 |  * @param {Object} variables the variables to forward onto the GraphQL server
27 |  * */
28 | export default function separateArgs(fieldSchema, reqASTArgs, paginationWords, variables) {
29 |   if (!fieldSchema.args) {
30 |     throw new Error(`${fieldSchema.name} does not support arguments. Check your GraphQL query.`);
31 |   }
32 |   const responseType = ensureTypeFromNonNull(fieldSchema.type);
33 |   const regularArgs = {};
34 |   const paginationArgs = {};
35 |   const paginationWordKeys = Object.keys(paginationWords);
36 |   const {acceptsPaginationArgs, acceptsRegularArgs} = acceptsArgs(fieldSchema, paginationWords, paginationWordKeys);
37 |   let hasPagination = false;
38 |   for (let i = 0; i < reqASTArgs.length; i++) {
39 |     const arg = reqASTArgs[i];
40 |     // if cashay added this argument, ignore it
41 |     // TODO figure out another way. i hate checking constructors.
42 |     if (arg.constructor.name === 'RequestArgument') continue;
43 |     const argName = arg.name.value;
44 |     if (!fieldSchema.args[argName]) {
45 |       throw new Error(`${fieldSchema.name} does not support ${argName}`)
46 |     }
47 |     const argValue = getVariableValue(arg, variables);
48 |     if (argValue === undefined) continue;
49 |     let paginationMeaning = paginationWordKeys.find(pageWord => paginationWords[pageWord] === argName);
50 |     if (paginationMeaning) {
51 |       if (paginationMeaning === BEFORE || paginationMeaning === AFTER) {
52 |         throw new Error(`Supplying pagination cursors to cashay is not supported. ${variables}`)
53 |       }
54 |       if (hasPagination === true) {
55 |         throw new Error(`Only one pagination argument can be supplied at a time. ${variables}`)
56 |       }
57 |       if (responseType.kind !== LIST) {
58 |         throw new Error(`${fieldSchema.name} is not a List. ${variables} should not contain pagination args`);
59 |       }
60 |       paginationArgs[paginationMeaning] = +argValue;
61 |       hasPagination = true;
62 |     } else {
63 |       regularArgs[argName] = argValue;
64 |     }
65 |   }
66 |   return {
67 |     regularArgs: acceptsRegularArgs && regularArgs,
68 |     paginationArgs: acceptsPaginationArgs && paginationArgs
69 |   }
70 | };
71 | 


--------------------------------------------------------------------------------
/src/query/__tests__/parseAndInitializeQuery-data.js:
--------------------------------------------------------------------------------
  1 | export const fragmentQueryString = `
  2 | query {
  3 |   getRecentPosts {
  4 |     _id,
  5 |     author {
  6 |       ...getAuthor
  7 |       _id
  8 |     },
  9 |   }
 10 | }
 11 | 
 12 | fragment getAuthor on AuthorType {
 13 |   	name
 14 | }`;
 15 | 
 16 | export const inlineQueryString = `
 17 | query {
 18 |   getRecentPosts {
 19 |     _id,
 20 |     author {
 21 |       ... on AuthorType {
 22 |   	    name
 23 |       }
 24 |       _id
 25 |     },
 26 |   }
 27 | }`;
 28 | 
 29 | export const inlineQueryStringWithoutId = `
 30 | query {
 31 |   getRecentPosts {
 32 |     author {
 33 |       ... on AuthorType {
 34 |   	    name
 35 |       }
 36 |       _id
 37 |     },
 38 |   }
 39 | }`;
 40 | 
 41 | export const unionQueryString = `
 42 | query {
 43 |   getGroup(_id: "g123") {
 44 |     _id
 45 |     owner {
 46 |       __typename
 47 |       _id
 48 |       ... on AuthorType {
 49 |         name
 50 |         twitterHandle
 51 |       }
 52 |     }
 53 |   }
 54 | }`;
 55 | 
 56 | export const unionQueryStringWithoutTypename = `
 57 | query {
 58 |   getGroup(_id: "g123") {
 59 |     _id
 60 |     owner {
 61 |       _id
 62 |       ... on AuthorType {
 63 |         name
 64 |         twitterHandle
 65 |       }
 66 |     }
 67 |   }
 68 | }`;
 69 | 
 70 | export const unionQueryStringWithExtraTypenameId = `
 71 | query {
 72 |   getGroup(_id: "g123") {
 73 |     _id
 74 |     owner {
 75 |       __typename
 76 |       _id
 77 |       ... on AuthorType {
 78 |         __typename
 79 |         _id
 80 |         name
 81 |         twitterHandle
 82 |       }
 83 |     }
 84 |   }
 85 | }`;
 86 | 
 87 | export const queryWithSortedArgs = `
 88 | query {
 89 |   getLatestPost {
 90 |     _id
 91 | 		title(inReverse: true, language: "english")
 92 |   }
 93 | }`;
 94 | 
 95 | export const queryWithUnsortedArgs = `
 96 | query {
 97 |   getLatestPost {
 98 |     _id
 99 | 		title(language: "english", inReverse: true)
100 |   }
101 | }`;
102 | 


--------------------------------------------------------------------------------
/src/query/__tests__/parseAndInitializeQuery-tests.js:
--------------------------------------------------------------------------------
 1 | import test from 'ava';
 2 | import 'babel-register';
 3 | import parseAndInitializeQuery from '../parseAndInitializeQuery';
 4 | import clientSchema from '../../__tests__/clientSchema.json';
 5 | import {parseSortPrint, sortPrint} from '../../__tests__/parseSortPrint';
 6 | import {
 7 |   fragmentQueryString,
 8 |   inlineQueryString,
 9 |   inlineQueryStringWithoutId,
10 |   unionQueryString,
11 |   unionQueryStringWithoutTypename,
12 |   unionQueryStringWithExtraTypenameId,
13 |   queryWithUnsortedArgs,
14 |   queryWithSortedArgs
15 | } from './parseAndInitializeQuery-data';
16 | 
17 | test('inline a fragment spread', t => {
18 |   const initializedAST = parseAndInitializeQuery(fragmentQueryString, clientSchema, '_id');
19 |   const actual = sortPrint(initializedAST);
20 |   const expected = parseSortPrint(inlineQueryString);
21 |   t.deepEqual(actual, expected);
22 | });
23 | 
24 | test('add an id field to the request', t => {
25 |   const initializedAST = parseAndInitializeQuery(inlineQueryStringWithoutId, clientSchema, '_id');
26 |   const actual = sortPrint(initializedAST);
27 |   const expected = parseSortPrint(inlineQueryString);
28 |   t.deepEqual(actual, expected);
29 | });
30 | 
31 | test('add a __typename field to the union request', t => {
32 |   const initializedAST = parseAndInitializeQuery(unionQueryStringWithoutTypename, clientSchema, '_id');
33 |   const actual = sortPrint(initializedAST);
34 |   const expected = parseSortPrint(unionQueryString);
35 |   t.deepEqual(actual, expected);
36 | });
37 | 
38 | test('remove extra __typename and id fields from fragments', t => {
39 |   const initializedAST = parseAndInitializeQuery(unionQueryStringWithExtraTypenameId, clientSchema, '_id');
40 |   const actual = sortPrint(initializedAST);
41 |   const expected = parseSortPrint(unionQueryString);
42 |   t.deepEqual(actual, expected);
43 | });
44 | 
45 | test('sort arguments by name', t => {
46 |   const initializedAST = parseAndInitializeQuery(queryWithUnsortedArgs, clientSchema, '_id');
47 |   const actual = sortPrint(initializedAST);
48 |   const expected = parseSortPrint(queryWithSortedArgs);
49 |   t.deepEqual(actual, expected);
50 | });
51 | 


--------------------------------------------------------------------------------
/src/query/flushDependencies.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * walk the normalized response & grab the deps for each entity. put em all in a Set & flush it down the toilet
 3 |  */
 4 | export default function flushDependencies(entitiesDiff, denormalizedDeps, cachedQueries, op, key) {
 5 |   const keyFlush = makeFlushSet(entitiesDiff, denormalizedDeps, op, key);
 6 |   const componentKeys = Object.keys(keyFlush);
 7 |   for (let i = 0; i < componentKeys.length; i++) {
 8 |     const componentKey = componentKeys[i];
 9 |     const keysToFlush = keyFlush[componentKey];
10 |     const cachedComponentQuery = cachedQueries[componentKey];
11 |     if (cachedComponentQuery) {
12 |       for (let flushedKey of keysToFlush) {
13 |         cachedComponentQuery.responses[flushedKey] = undefined;
14 |       }
15 |     }
16 |   }
17 | }
18 | 
19 | /**
20 |  * Crawl the dependency tree snagging up everything that will be invalidated
21 |  * Safety checks required because subs affect queries, but not the other way around
22 |  *
23 |  */
24 | const makeFlushSet = (entitiesDiff, denormalizedDeps, op, key) => {
25 |   const keyFlush = {};
26 |   const typeKeys = Object.keys(entitiesDiff);
27 |   for (let i = 0; i < typeKeys.length; i++) {
28 |     const typeName = typeKeys[i];
29 |     const typeInDependencyTree = denormalizedDeps[typeName];
30 |     if (!typeInDependencyTree) continue;
31 |     const newType = entitiesDiff[typeName];
32 |     const entityKeys = Object.keys(newType);
33 |     for (let j = 0; j < entityKeys.length; j++) {
34 |       const entityName = entityKeys[j];
35 |       const entityInDependencyTree = typeInDependencyTree[entityName];
36 |       if (!entityInDependencyTree) continue;
37 |       const entityInDependencyTreeKeys = Object.keys(entityInDependencyTree);
38 |       for (let k = 0; k < entityInDependencyTreeKeys.length; k++) {
39 |         const dependentComponent = entityInDependencyTreeKeys[k];
40 |         const newDependencyKeySet = entityInDependencyTree[dependentComponent];
41 |         const incumbant = keyFlush[dependentComponent] || new Set();
42 |         keyFlush[dependentComponent] = new Set([...incumbant, ...newDependencyKeySet]);
43 |       }
44 |     }
45 |   }
46 | 
47 |   // ensure flushing the callee (if it's a sub it'll just get ignored later)
48 |   if (op) {
49 |     keyFlush[op] = keyFlush[op] || new Set();
50 |     keyFlush[op].add(key);
51 |   }
52 |   return keyFlush;
53 | };
54 | 


--------------------------------------------------------------------------------
/src/query/parseAndInitializeQuery.js:
--------------------------------------------------------------------------------
  1 | import {FRAGMENT_SPREAD, INLINE_FRAGMENT} from 'graphql/language/kinds';
  2 | import {
  3 |   convertFragmentToInline,
  4 |   CACHED,
  5 |   parse,
  6 |   clone,
  7 |   ensureRootType,
  8 |   TYPENAME,
  9 |   teardownDocumentAST,
 10 |   getFieldSchema,
 11 |   CACHED_ARGS
 12 | } from '../utils';
 13 | import {TypeKind} from 'graphql/type/introspection';
 14 | import {Field} from '../helperClasses';
 15 | 
 16 | const {ENUM, UNION, SCALAR, OBJECT} = TypeKind;
 17 | 
 18 | const validateCachedDirective = (cachedDirective) => {
 19 |   const argsArr = cachedDirective.arguments;
 20 |   const cachedArgs = {};
 21 |   for (let i = 0; i < argsArr.length; i++) {
 22 |     const arg = argsArr[i];
 23 |     const argName = arg.name.value;
 24 |     if (!CACHED_ARGS.includes(argName)) {
 25 |       throw new Error(`@cached only accepts ${JSON.stringify(CACHED_ARGS)} not ${argName}.`);
 26 |     }
 27 |     cachedArgs[argName] = arg;
 28 |   }
 29 |   if (cachedArgs.id && cachedArgs.ids) {
 30 |     throw new Error(`@entity can receive either an 'id' or 'ids' arg, not both`);
 31 |   }
 32 |   if (!cachedArgs.type) {
 33 |     throw new Error(`@entity requires a type arg.`);
 34 |   }
 35 | };
 36 | 
 37 | export default function parseAndInitializeQuery(queryString, schema, idFieldName) {
 38 |   const ast = parse(queryString);
 39 |   const {operation, fragments} = teardownDocumentAST(ast.definitions);
 40 |   const catalogFields = [idFieldName, TYPENAME];
 41 |   const initializeQueryAST = (fields, parentSchema) => {
 42 |     for (let i = 0; i < fields.length; i++) {
 43 |       // convert fragment spreads into inline so we can minimize queries later
 44 |       let field = fields[i];
 45 |       if (field.kind === FRAGMENT_SPREAD) {
 46 |         const fragment = clone(fragments[field.name.value]);
 47 |         field = fields[i] = convertFragmentToInline(fragment);
 48 |       }
 49 |       // if it's an inline fragment, set schema to the typecondition, or parentSchema if null
 50 |       if (field.kind === INLINE_FRAGMENT) {
 51 |         const subSchema = field.typeCondition ? schema.types[field.typeCondition.name.value] : parentSchema;
 52 |         const children = field.selectionSet.selections;
 53 |         for (let fieldToRemove of catalogFields) {
 54 |           const idx = children.findIndex(child => child.name && child.name.value === fieldToRemove);
 55 |           if (idx !== -1) {
 56 |             children.splice(idx, 1);
 57 |           }
 58 |         }
 59 |         initializeQueryAST(children, subSchema);
 60 |         continue;
 61 |       }
 62 |       // sort args once here to make sure the key is the same in the store w/o sorting later
 63 |       if (field.arguments && field.arguments.length) {
 64 |         field.arguments.sort((a, b) => a.name.value > b.name.value);
 65 |       }
 66 |       const cachedDirective = field.directives && field.directives.find(d => d.name.value === CACHED);
 67 |       if (field.selectionSet) {
 68 |         const children = field.selectionSet.selections;
 69 |         // if no resolve function is present, then it might just be a sort or filter
 70 |         if (cachedDirective) {
 71 |           validateCachedDirective(cachedDirective);
 72 |         } else {
 73 |           const fieldSchema = getFieldSchema(field, parentSchema, schema);
 74 |           const rootFieldSchema = ensureRootType(fieldSchema.type);
 75 |           const typeSchema = schema.types[rootFieldSchema.name];
 76 |           const fieldsToAdd = typeSchema.kind === UNION ? catalogFields : typeSchema.fields[idFieldName] ? [idFieldName] : [];
 77 |           for (let fieldToAdd of fieldsToAdd) {
 78 |             const child = children.find(child => child.name && child.name.value === fieldToAdd);
 79 |             if (!child) {
 80 |               children.push(new Field({name: fieldToAdd}))
 81 |             }
 82 |           }
 83 |           initializeQueryAST(children, typeSchema);
 84 |         }
 85 |       } else if (cachedDirective) {
 86 |         throw new Error(`@entity can only be applied to an object or array`);
 87 |       } else if (field.name.value !== TYPENAME && parentSchema.kind === OBJECT) {
 88 |         // naively rule out unions, we can deal with those later
 89 |         const fieldSchema = getFieldSchema(field, parentSchema, schema);
 90 |         const rootFieldSchema = ensureRootType(fieldSchema.type);
 91 |         if (rootFieldSchema.kind !== ENUM && rootFieldSchema.kind !== SCALAR) {
 92 |           throw new Error(`Field ${rootFieldSchema.name} is an object but doesn't have a sub selection.`)
 93 |         }
 94 |       }
 95 |     }
 96 |   };
 97 |   initializeQueryAST(operation.selectionSet.selections, schema.querySchema);
 98 |   ast.definitions = [operation];
 99 |   return ast;
100 | };
101 | 
102 | 


--------------------------------------------------------------------------------
/src/query/printMinimalQuery.js:
--------------------------------------------------------------------------------
 1 | import {print} from 'graphql/language/printer';
 2 | import {VARIABLE} from 'graphql/language/kinds';
 3 | import {getMissingRequiredVariables} from './queryHelpers';
 4 | import createVariableDefinitions from '../createVariableDefinitions';
 5 | import {ensureRootType, LIVE, CACHED} from '../utils';
 6 | 
 7 | export const printMinimalQuery = (reqAST, idFieldName, variables, op, schema, forceFetch) => {
 8 |   const context = {
 9 |     forceFetch,
10 |     op,
11 |     schema
12 |   };
13 |   reqAST.variableDefinitions = minimizeQueryAST(reqAST, idFieldName, variables, schema.querySchema, [], context);
14 |   return print(reqAST)
15 | };
16 | 
17 | const unqueriableDirectives = [LIVE, CACHED];
18 | const safeToSendDirectives = (directives) => {
19 |   for (let i = 0; i < directives.length; i++) {
20 |     const directive = directives[i];
21 |     if (unqueriableDirectives.includes(directive.name.value)) {
22 |       return false;
23 |     }
24 |   }
25 |   return true;
26 | };
27 | 
28 | // mutates initialVariableDefinitions
29 | const minimizeQueryAST = (reqAST, idFieldName, variables, subSchema, initialVariableDefinitions = [], context) => {
30 |   const {selections} = reqAST.selectionSet;
31 |   for (let i = 0; i < selections.length; i++) {
32 |     const field = selections[i];
33 |     // if it has to go to the server, create some variable definitions and remove the pieces that don't have the required vars
34 |     if ((field.sendToServer || context.forceFetch) && safeToSendDirectives(field.directives)) {
35 |       const fieldSchema = subSchema.fields[field.name.value];
36 |       if (field.arguments && field.arguments.length) {
37 |         const createVarDefContext = {...context, initialVariableDefinitions};
38 |         const {variableDefinitions} = createVariableDefinitions(field.arguments, fieldSchema, false, createVarDefContext);
39 |         const allVarDefs = [...initialVariableDefinitions, ...variableDefinitions];
40 |         const missingRequiredVars = getMissingRequiredVariables(allVarDefs, variables);
41 |         const hasMissingVar = findMissingVar(field.arguments, missingRequiredVars);
42 |         if (hasMissingVar) {
43 |           // remove fields that aren't given the vars they need to be successful
44 |           selections[i] = undefined;
45 |           continue;
46 |         } else {
47 |           // MUTATIVE
48 |           initialVariableDefinitions.push(...variableDefinitions);
49 |         }
50 |       }
51 |       if (field.selectionSet) {
52 |         const fieldSchemaType = ensureRootType(fieldSchema.type);
53 |         const nextSchema = context.schema.types[fieldSchemaType.name];
54 |         // mutates initialVariableDefinitions
55 |         minimizeQueryAST(field, idFieldName, variables, nextSchema, initialVariableDefinitions, context);
56 |       }
57 |     } else if (field.name.value !== idFieldName) {
58 |       selections[i] = undefined;
59 |     }
60 |   }
61 |   // clean up unnecessary children
62 |   const minimizedFields = selections.filter(Boolean);
63 | 
64 |   // if there aren't any fields or maybe just an unnecessary id field, remove the req
65 |   const firstField = minimizedFields[0];
66 |   if (!firstField ||
67 |     (minimizedFields.length === 1 && !firstField.sendToServer && firstField.name && firstField.name.value === idFieldName)) {
68 |     reqAST.selectionSet = null;
69 |   } else {
70 |     reqAST.selectionSet.selections = minimizedFields;
71 |   }
72 |   // length will be >= than how it started
73 |   return initialVariableDefinitions;
74 | };
75 | 
76 | const findMissingVar = (fieldArgs, missingRequiredVars) => {
77 |   for (let i = 0; i < fieldArgs.length; i++) {
78 |     const fieldArg = fieldArgs[i];
79 |     if (fieldArg.value.kind === VARIABLE) {
80 |       if (missingRequiredVars.includes(fieldArg.name.value)) {
81 |         return true;
82 |       }
83 |     }
84 |   }
85 | };
86 | 


--------------------------------------------------------------------------------
/src/query/queryHelpers.js:
--------------------------------------------------------------------------------
  1 | import {NON_NULL_TYPE} from 'graphql/language/kinds';
  2 | import {isObject} from '../utils';
  3 | 
  4 | /*
  5 |  * reduce the fields to merge into the state
  6 |  * doing this here means a smaller flushSet and fewer invalidations
  7 |  * currently we mutate normalizedResponse. it may be worthwhile to make this pure
  8 |  * */
  9 | export const shortenNormalizedResponse = (normalizedResponse, cashayState) => {
 10 |   // TODO rewrite by recurisvely finding the outer join
 11 |   // const {entities} = normalizedResponse;
 12 |   // const diff = {};
 13 |   // if (!entities) return;
 14 |   // const typeKeys = Object.keys(entities);
 15 |   // for (let i = 0; i < typeKeys.length; i++) {
 16 |   //   const typeName = typeKeys[i];
 17 |   //   const typeInResponse = entities[typeName];
 18 |   //   const typeInState = cashayState.entities[typeName];
 19 |   //   // const typeInDiff = diff[typeName];
 20 |   //   if (!typeInState) {
 21 |   //     diff[typeName] = typeInResponse;
 22 |   //     continue;
 23 |   //   }
 24 |   //   diff[typeName] = diff[typeName] || {};
 25 |   //   const typeInDiff = diff[typeName];
 26 |   //   const typeKeys = Object.keys(typeInResponse);
 27 |   //   for (let j = 0; j < typeKeys.length; j++) {
 28 |   //     const entityName = typeKeys[j];
 29 |   //     const entityInState = typeInState[entityName];
 30 |   //     const entityInRespose = typeInResponse[entityName];
 31 |   //     if (!entityInState) {
 32 |   //       typeInDiff[entityName] = entityInRespose;
 33 |   //       continue;
 34 |   //     }
 35 |   //     diff[entityName] = diff[entityName]
 36 |   //     const newEntity = typeInResponse[entityName];
 37 |   //     // entityInState could be a superset of newEntity and we'd still want to remove newEntity
 38 |   //     // so, we can't use a single stringify comparison, we have to walk each item in newEntity
 39 |   //     // and remove items that are deepEqual (since an entity can have a nested array or object)
 40 |   //     const reducedNewEntity = deepEqualAndReduce(entityInState, newEntity);
 41 |   //   }
 42 |   // }
 43 |   return Object.keys(normalizedResponse).length && normalizedResponse;
 44 | };
 45 | 
 46 | /*
 47 |  * Returns a copy of the newEntity that does not include any props where the value of both are equal
 48 |  */
 49 | const deepEqualAndReduce = (state, newEntity, reducedNewItem = {}) => {
 50 |   const propsToCheck = Object.keys(newEntity);
 51 |   for (let i = 0; i < propsToCheck.length; i++) {
 52 |     const propName = propsToCheck[i];
 53 |     const newEntityProp = newEntity[propName];
 54 | 
 55 |     // it the prop doesn't exist in state, put it there
 56 |     if (!state.hasOwnProperty(propName)) {
 57 |       reducedNewItem[propName] = newEntityProp;
 58 |       continue;
 59 |     }
 60 | 
 61 |     // strict-equal must come after hasOwnProperty because the two could be null
 62 |     const stateProp = state[propName];
 63 |     if (stateProp === newEntityProp) {
 64 |       continue;
 65 |     }
 66 | 
 67 |     // if they're not equal, it could be an array, object, or scalar
 68 |     if (Array.isArray(newEntityProp)) {
 69 |       if (Array.isArray(stateProp) && newEntityProp.length === stateProp.length) {
 70 |         //  an array of objects here is wrong. Better to be performant for those who play by the rules
 71 |         let isShallowEqual = true;
 72 |         for (let i = 0; i < newEntityProp.length; i++) {
 73 |           if (newEntityProp[i] !== stateProp[i]) {
 74 |             isShallowEqual = false;
 75 |             break;
 76 |           }
 77 |         }
 78 |         if (!isShallowEqual) {
 79 |           // TODO either recurse or jsonEquals this
 80 |           reducedNewItem[propName] = newEntityProp;
 81 |         }
 82 |       } else {
 83 |         reducedNewItem[propName] = newEntityProp;
 84 |       }
 85 |     } else if (isObject(newEntityProp)) {
 86 |       if (isObject(stateProp)) {
 87 |         // they're both objects, we must go deeper
 88 |         reducedNewItem[propName] = deepEqualAndReduce(stateProp, newEntityProp);
 89 |       } else {
 90 |         reducedNewItem[propName] = newEntityProp;
 91 |       }
 92 |     } else {
 93 |       // they're non-equal scalars
 94 |       reducedNewItem[propName] = newEntityProp;
 95 |     }
 96 |   }
 97 |   return reducedNewItem;
 98 | };
 99 | 
100 | /**
101 |  * Mutation ASTs are generated, aggregated, printed, and cached for performance.
102 |  * When a new query comes along, the mutation might need to request additional fields for it
103 |  * If this happens, we need to invalidate the cached mutation
104 |  *
105 |  * @param {String} op the query operation that is affecting the mutation
106 |  * @param {Object} cachedMutations the mutations that are cached in the singleton
107 |  *
108 |  */
109 | export const invalidateMutationsOnNewQuery = (op, cachedMutations) => {
110 |   const activeMutations = Object.keys(cachedMutations);
111 |   for (let i = 0; i < activeMutations.length; i++) {
112 |     const mutationName = activeMutations[i];
113 |     const mutation = cachedMutations[mutationName];
114 |     // TODO handle logic for keys?
115 |     if (mutation.activeQueries[op]) {
116 |       mutation.clear();
117 |     }
118 |   }
119 | };
120 | 
121 | export const getMissingRequiredVariables = (variableDefinitions, variables) => {
122 |   const missingVars = [];
123 |   for (let i = 0; i < variableDefinitions.length; i++) {
124 |     const def = variableDefinitions[i];
125 |     if (def.type.kind === NON_NULL_TYPE) {
126 |       const defKey = def.variable.name.value;
127 |       if (!variables[defKey]) {
128 |         missingVars.push(defKey);
129 |       }
130 |     }
131 |   }
132 |   return missingVars;
133 | };
134 | 
135 | export const equalPendingQueries = (baseQuery, {op, key, variables}) => {
136 |   const {op: baseComponent, key: baseKey, variables: baseVariables} = baseQuery;
137 |   if (baseComponent !== op) return false;
138 |   if (key !== baseKey) return false;
139 |   const baseVariablesKeys = Object.keys(baseVariables);
140 |   const variablesKeys = Object.keys(variables);
141 |   if (baseVariablesKeys.length !== variablesKeys.length) return false;
142 |   // this is just a heuristic that doesn't check variable values.
143 |   // that's OK because unique queries with unique variables shouldn't share the same op name
144 |   // Also, calling a query twice with different vars before you get the results of the first is an unsupported anti-pattern
145 |   return true;
146 | }
147 | 


--------------------------------------------------------------------------------
/src/schema/__tests__/cashay-loader-tests.js:
--------------------------------------------------------------------------------
 1 | import 'babel-register';
 2 | import test from 'ava';
 3 | 
 4 | import cashayLoader from '../cashay-loader';
 5 | 
 6 | class MockLoaderParent {
 7 |   constructor(loader, testCallback) {
 8 |     this.loader = loader;
 9 |     this.callback = testCallback;
10 |   }
11 |   async() { return this.callback; }
12 |   cacheable() { return; }
13 |   exec(content, resource) {
14 |     return () =>
15 |       new Promise((resolve) => resolve({ querySchema: "test document" }));
16 |   }
17 |   load(testContent) { return this.loader(testContent); }
18 | }
19 | 
20 | test('cashay-loader is function', t => {
21 |   t.plan(1);
22 | 
23 |   t.is(typeof cashayLoader, 'function');
24 | });
25 | 
26 | test.cb('cashay-loader returns raw module object', t => {
27 |   t.plan(2);
28 | 
29 |   const callback = (errors, doc) => {
30 |     t.is(errors, null);
31 |     t.regex(doc, /^module.exports = {/);
32 |     t.end();
33 |   }
34 | 
35 |   const loader = new MockLoaderParent(cashayLoader, callback);
36 |   loader.load();
37 | });
38 | 


--------------------------------------------------------------------------------
/src/schema/cashay-loader.js:
--------------------------------------------------------------------------------
 1 | module.exports = function(content) {
 2 |   // Allow webpack to be smart about required dependencies:
 3 |   this.cacheable && this.cacheable();
 4 |   const callback = this.async();
 5 |   // Execute the supplied javascript, receive promise:
 6 |   const doc = this.exec(content, this.resource);
 7 |   doc(this.resourceQuery).then(function (schema) {
 8 |     // Await the yield of a cashay schema:
 9 |     callback(null, "module.exports = " + JSON.stringify(schema));
10 |   });
11 | };
12 | 


--------------------------------------------------------------------------------
/src/schema/introspectionQuery.js:
--------------------------------------------------------------------------------
 1 | module.exports = `
 2 | query {
 3 |   __schema {
 4 |     queryType { name }
 5 |     mutationType { name }
 6 |     subscriptionType { name }
 7 |     types {
 8 |     ...FullType
 9 |     }
10 |     directives {
11 |       name
12 |       args {
13 |       ...InputValue
14 |       }
15 |       onOperation
16 |       onFragment
17 |       onField
18 |     }
19 |   }
20 | }
21 | fragment FullType on __Type {
22 |   kind
23 |   name
24 |   fields(includeDeprecated: false) {
25 |     name
26 |     args {
27 |     ...InputValue
28 |     }
29 |     type {
30 |     ...TypeRef
31 |     }
32 |   }
33 |   inputFields {
34 |   ...InputValue
35 |   }
36 |   interfaces {
37 |   ...TypeRef
38 |   }
39 |   enumValues(includeDeprecated: false) {
40 |     name
41 |   }
42 |   possibleTypes {
43 |   ...TypeRef
44 |   }
45 | }
46 | fragment InputValue on __InputValue {
47 |   name
48 |   type { ...TypeRef }
49 |   defaultValue
50 | }
51 | fragment TypeRef on __Type {
52 |   kind
53 |   name
54 |   ofType {
55 |     kind
56 |     name
57 |     ofType {
58 |       kind
59 |       name
60 |       ofType {
61 |         kind
62 |         name
63 |       }
64 |     }
65 |   }
66 | }`;
67 | 


--------------------------------------------------------------------------------
/src/schema/transformSchema.js:
--------------------------------------------------------------------------------
  1 | import introspectionQuery from './introspectionQuery';
  2 | 
  3 | export default async function transformSchema(rootSchema, graphql) {
  4 |   const initialResult = await graphql(rootSchema, introspectionQuery);
  5 | 
  6 |   if (initialResult.errors) {
  7 |     throw new Error(`unable to parse schema: ${initialResult.errors}`);
  8 |   }
  9 | 
 10 |   return makeMinimalSchema(initialResult.data.__schema);
 11 | }
 12 | 
 13 | const isObject = val => val && typeof val === 'object';
 14 | const removeNullsFromList = list => {
 15 |   for (let item of list) {
 16 |     removeNullsFromObject(item)
 17 |   }
 18 | };
 19 | const removeNullsFromObject = obj => {
 20 |   const itemKeys = Object.keys(obj);
 21 |   for (let itemKey of itemKeys) {
 22 |     const field = obj[itemKey];
 23 |     if (Array.isArray(field)) {
 24 |       removeNullsFromList(field);
 25 |     } else if (isObject(field)) {
 26 |       removeNullsFromObject(field)
 27 |     } else if (field === null) {
 28 |       delete obj[itemKey];
 29 |     }
 30 |   }
 31 | };
 32 | 
 33 | //TODO filter out interfaces
 34 | export const makeMinimalSchema = schema => {
 35 |   removeNullsFromObject(schema);
 36 |   const queryName = schema.queryType && schema.queryType.name;
 37 |   const mutationName = schema.mutationType && schema.mutationType.name;
 38 |   const subscriptionName = schema.subscriptionType && schema.subscriptionType.name;
 39 |   const filteredTypes = schema.types.filter(type => !type.name.startsWith('__'));
 40 | 
 41 |   for (let type of filteredTypes) {
 42 |     if (type.fields) {
 43 |       for (let field of type.fields) {
 44 |         if (field.args) {
 45 |           if (field.args.length) {
 46 |             field.args = objArrayToHashMap(field.args);
 47 |           } else {
 48 |             delete field.args;
 49 |           }
 50 |         }
 51 |       }
 52 |       type.fields = objArrayToHashMap(type.fields);
 53 |     }
 54 |     if (type.enumValues) {
 55 |       type.enumValues = objArrayToHashMap(type.enumValues);
 56 |     }
 57 |     if (type.inputFields) {
 58 |       type.inputFields = objArrayToHashMap(type.inputFields)
 59 |     }
 60 |     if (type.possibleTypes) {
 61 |       type.possibleTypes = objArrayToHashMap(type.possibleTypes);
 62 |     }
 63 |     if (type.interfaces) {
 64 |       if (type.interfaces.length) {
 65 |         type.interfaces = objArrayToHashMap(type.interfaces);
 66 |       } else {
 67 |         delete type.interfaces;
 68 |       }
 69 |     }
 70 |   }
 71 |   const filteredTypesMap = objArrayToHashMap(filteredTypes);
 72 |   const filteredDirectives = schema.directives.filter(directive => {
 73 |     return directive.name !== 'deprecated';
 74 |   });
 75 |   for (let directive of filteredDirectives) {
 76 |     directive.args = objArrayToHashMap(directive.args);
 77 |   }
 78 |   const filteredDirectivesMap = objArrayToHashMap(filteredDirectives);
 79 |   const querySchema = filteredTypesMap[queryName];
 80 |   delete filteredTypesMap[queryName];
 81 |   const mutationSchema = filteredTypesMap[mutationName];
 82 |   delete filteredTypesMap[mutationName];
 83 |   const subscriptionSchema = filteredTypesMap[subscriptionName];
 84 |   delete filteredTypesMap[subscriptionName];
 85 | 
 86 |   const finalResult = {
 87 |     querySchema,
 88 |     types: filteredTypesMap,
 89 |     directives: filteredDirectivesMap
 90 |   };
 91 |   if (mutationSchema) {
 92 |     finalResult.mutationSchema = mutationSchema;
 93 |   }
 94 |   if (subscriptionSchema) {
 95 |     finalResult.subscriptionSchema = subscriptionSchema;
 96 |   }
 97 |   return finalResult;
 98 | };
 99 | 
100 | const objArrayToHashMap = arr => {
101 |   const hashMap = {};
102 |   for (let field of arr) {
103 |     hashMap[field.name] = field;
104 |   }
105 |   return hashMap;
106 | };
107 | 


--------------------------------------------------------------------------------
/src/schema/updateSchema.babel.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | 
3 | require('babel-register');
4 | require('babel-polyfill');
5 | require('./updateSchema').default();
6 | 


--------------------------------------------------------------------------------
/src/schema/updateSchema.js:
--------------------------------------------------------------------------------
 1 | import path from 'path';
 2 | import fs from 'fs';
 3 | import minimist from 'minimist';
 4 | import introspectionQuery from './introspectionQuery';
 5 | import fetch from 'isomorphic-fetch';
 6 | import transformSchema from './transformSchema';
 7 | 
 8 | // why instanceof is still a thing is beyond me...
 9 | const graphql = require(path.join(process.cwd(), 'node_modules', 'graphql')).graphql;
10 | 
11 | const urlRegex = /^(https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
12 | 
13 | export default async function updateSchema() {
14 |   const args = minimist(process.argv);
15 |   const inputArg = args._[2] || '';
16 |   const relativeOutputPath = process.argv[3] || './clientSchema.json';
17 |   const outputPath = path.join(process.cwd(), relativeOutputPath);
18 |   const spacing = args.production ? 0 : 2;
19 |   const oncomplete = args.oncomplete && require(path.join(process.cwd(), args.oncomplete));
20 | 
21 |   const rootSchema = await getSchema(inputArg);
22 |   const finalResult = await transformSchema(rootSchema, graphql);
23 |   try {
24 |     fs.writeFileSync(outputPath, JSON.stringify(finalResult, null, spacing));
25 |     console.log(`You got yourself a schema! See it here: ${outputPath}`);
26 |     oncomplete && oncomplete();
27 |   } catch (e) {
28 |     console.log(`Error writing schema to file: ${e}`)
29 |   }
30 | }
31 | 
32 | const getSchema = async inputArg => {
33 |   if (urlRegex.test(inputArg)) {
34 |     const body = JSON.stringify({query: introspectionQuery});
35 |     const res = await fetch(inputArg, {method: 'POST', body});
36 |     const {status, statusText} = res;
37 |     let resJSON;
38 |     if (status >= 200 && status < 300) {
39 |       resJSON = await res.json();
40 |     } else {
41 |       console.log(`Could not reach your GraphQL server: ${inputArg}.
42 |         Error: ${statusText}`);
43 |       return
44 |     }
45 |     if (resJSON.errors) {
46 |       console.log(`The graphQL endpoint returned the following errors: ${JSON.stringify(resJSON.errors)}`);
47 |     }
48 |     return resJSON.data;
49 |   }
50 |   const relativeInputPath = path.join(process.cwd(), inputArg);
51 |   let rootSchema;
52 |   try {
53 |     rootSchema = require(relativeInputPath).default;
54 |   } catch (e) {
55 |     console.log('Error requiring schema', e);
56 |   }
57 |   return rootSchema;
58 | };
59 | 


--------------------------------------------------------------------------------
/src/subscribe/processSubscriptionDoc.js:
--------------------------------------------------------------------------------
  1 | import {ADD, UPDATE, UPSERT, REMOVE, REMOVAL_FLAG, shallowEqual} from '../utils';
  2 | import {
  3 |   ADD_SUBSCRIPTION,
  4 |   UPDATE_SUBSCRIPTION,
  5 |   REMOVE_SUBSCRIPTION
  6 | } from '../normalize/duck';
  7 | import normalizeResponse from '../normalize/normalizeResponse';
  8 | 
  9 | import {TypeKind} from 'graphql/type/introspection';
 10 | 
 11 | const {UNION} = TypeKind;
 12 | 
 13 | const getSafeHandler = (handler, idxInCache) => {
 14 |   if (handler !== UPSERT) return handler;
 15 |   return idxInCache === -1 ? ADD : UPDATE;
 16 | };
 17 | 
 18 | const immutableRemove = (arr, idx) => {
 19 |   return [...arr.slice(0, idx), ...arr.slice(idx + 1)]
 20 | };
 21 | 
 22 | const immutableUpdate = (arr, idx, updatedDoc) => {
 23 |   return [...arr.slice(0, idx), updatedDoc, ...arr.slice(idx + 1)]
 24 | };
 25 | 
 26 | const checkCanDelete = (document, oldDenormResult, context) => {
 27 |   const {entities, typeSchema, idFieldName} = context;
 28 |   const typeName = typeSchema.kind === UNION ? oldDenormResult.data.__typename : typeSchema.name;
 29 |   const docId = document[idFieldName];
 30 |   const oldEntity = entities[typeName] && entities[typeName][docId];
 31 |   // protect against 2 remove calls coming in quickly
 32 |   if (!oldEntity) return false;
 33 |   const docKeys = Object.keys(document);
 34 |   for (let i = 0; i < docKeys.length; i++) {
 35 |     const key = docKeys[i];
 36 |     if (oldEntity[key] !== document[key]) {
 37 |       return false;
 38 |     }
 39 |   }
 40 |   return true;
 41 | };
 42 | 
 43 | export default function processSubscriptionDoc(handler, document, oldDenormResult, oldNormResult, context) {
 44 |   const {idFieldName, typeSchema} = context;
 45 |   const docId = document[idFieldName];
 46 |   const isList = Array.isArray(oldDenormResult.data);
 47 |   if (isList) {
 48 |     const idxInCache = oldNormResult.findIndex(normDoc => normDoc.endsWith(docId));
 49 |     const safeHandler = getSafeHandler(handler, idxInCache);
 50 |     if (safeHandler === ADD) {
 51 |       const normalizedDoc = normalizeResponse(document, context, true);
 52 |       return {
 53 |         actionType: ADD_SUBSCRIPTION,
 54 |         denormResult: oldDenormResult.data.concat(document),
 55 |         oldDoc: null,
 56 |         newDoc: document,
 57 |         normEntities: normalizedDoc.entities,
 58 |         normResult: oldNormResult.concat(normalizedDoc.result)
 59 |       };
 60 |     } else if (safeHandler === REMOVE) {
 61 |       const oldDoc = oldDenormResult.data[idxInCache];
 62 |       // const canDelete = checkCanDelete(document, oldDenormResult, context);
 63 |       // const typeName = typeSchema.kind === UNION ? oldDoc.__typename : typeSchema.name;
 64 |       return {
 65 |         actionType: REMOVE_SUBSCRIPTION,
 66 |         denormResult: immutableRemove(oldDenormResult.data, idxInCache),
 67 |         oldDoc,
 68 |         newDoc: null,
 69 |         normEntities: {},
 70 |         // cannot safely remove here because another sub or @cached query might also use this doc
 71 |         // normEntities: canDelete ? {[typeName]: {[docId]: REMOVAL_FLAG}} : {},
 72 |         normResult: immutableRemove(oldNormResult, idxInCache)
 73 |       }
 74 |     } else if (safeHandler === UPDATE) {
 75 |       const oldDoc = oldDenormResult.data[idxInCache];
 76 |       // this shallow merge will break if the doc has nested docs
 77 |       const mergedDoc = {...oldDoc, ...document};
 78 |       if (shallowEqual(oldDoc, mergedDoc)) return;
 79 |       const normalizedDoc = normalizeResponse(mergedDoc, context, true);
 80 |       return {
 81 |         actionType: UPDATE_SUBSCRIPTION,
 82 |         denormResult: immutableUpdate(oldDenormResult.data, idxInCache, mergedDoc),
 83 |         oldDoc,
 84 |         newDoc: mergedDoc,
 85 |         normEntities: normalizedDoc.entities,
 86 |         normResult: immutableUpdate(oldNormResult, idxInCache, normalizedDoc.result)
 87 |       };
 88 |     }
 89 |   } else {
 90 |     const safeHandler = handler === UPSERT ? UPDATE : handler;
 91 |     if (safeHandler === ADD) {
 92 |       const {entities: normEntities, result: normResult} = normalizeResponse(document, context, true);
 93 |       return {
 94 |         actionType: ADD_SUBSCRIPTION,
 95 |         denormResult: document,
 96 |         oldDoc: null,
 97 |         newDoc: document,
 98 |         normEntities,
 99 |         normResult
100 |       }
101 |     } else if (safeHandler === UPDATE) {
102 |       const mergedDoc = {...oldDenormResult.data, ...document};
103 |       if (shallowEqual(oldDenormResult.data, mergedDoc)) return;
104 |       const {entities: normEntities, result: normResult} = normalizeResponse(mergedDoc, context, true);
105 |       return {
106 |         actionType: UPDATE_SUBSCRIPTION,
107 |         denormResult: mergedDoc,
108 |         oldDoc: oldDenormResult.data,
109 |         newDoc: mergedDoc,
110 |         normEntities,
111 |         normResult
112 |       }
113 |     } else if (safeHandler === REMOVE) {
114 |       const typeName = typeSchema.kind === UNION ? oldDenormResult.data.__typename : typeSchema.name;
115 |       return {
116 |         actionType: REMOVE_SUBSCRIPTION,
117 |         denormResult: null,
118 |         oldDoc: oldDenormResult.data,
119 |         newDoc: null,
120 |         normEntities: {[typeName]: {[docId]: REMOVAL_FLAG}},
121 |         normResult: null
122 |       };
123 |     }
124 |   }
125 | };
126 | 


--------------------------------------------------------------------------------
/src/transports/HTTPTransport.js:
--------------------------------------------------------------------------------
 1 | import fetch from 'isomorphic-fetch'
 2 | import defaultHandleErrors from './defaultHandleErrors';
 3 | import Transport from './Transport';
 4 | 
 5 | export default class HTTPTransport extends Transport {
 6 |   constructor(uri = '/graphql', init = {}, handleErrors = defaultHandleErrors) {
 7 |     super();
 8 |     this.uri = uri;
 9 |     this.init = init;
10 |     this.handleErrors = handleErrors;
11 |     this.sendToServer =  async (request) => {
12 |       const payload = {
13 |         ...this.init,
14 |         body: JSON.stringify(request),
15 |         headers: {
16 |           ...this.init.headers,
17 |           'Accept': '*/*',
18 |           'Content-Type': 'application/json'
19 |         },
20 |         method: 'POST'
21 |       };
22 |       const result = await fetch(this.uri, payload);
23 |       const {status, statusText} = result;
24 |       if (status >= 200 && status < 300) {
25 |         return await result.json();
26 |       } else {
27 |         return {
28 |           data: null,
29 |           errors: [{_error: statusText, status}]
30 |         };
31 |       }
32 |     }
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/transports/Transport.js:
--------------------------------------------------------------------------------
 1 | import defaultHandleErrors from './defaultHandleErrors';
 2 | 
 3 | export default class Transport {
 4 |   constructor(sendToServer, handleErrors = defaultHandleErrors) {
 5 |     this.sendToServer = sendToServer;
 6 |     this.handleErrors = handleErrors;
 7 |   }
 8 | 
 9 |   async handleQuery(request) {
10 |     const {data, errors} = await this.sendToServer(request);
11 |     const error = this.handleErrors(request, errors);
12 |     return error ? {data, error} : {data};
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/transports/defaultHandleErrors.js:
--------------------------------------------------------------------------------
 1 | const tryParse = str => {
 2 |   let obj;
 3 |   try {
 4 |     obj = JSON.parse(str);
 5 |   } catch (e) {
 6 |     return false;
 7 |   }
 8 |   return obj;
 9 | };
10 | 
11 | export default function defaultHandleErrors(request, errors, duckField = '_error') {
12 |   if (!errors) return;
13 |   // expect a human to put an end-user-safe message in the message field
14 |   const firstErrorMessage = errors[0].message;
15 |   if (!firstErrorMessage) return {errors};
16 |   const parsedError = tryParse(firstErrorMessage);
17 |   if (parsedError && parsedError.hasOwnProperty(duckField)) {
18 |     return parsedError;
19 |   }
20 |   return {errors};
21 | };
22 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
  1 | import {INLINE_FRAGMENT, OPERATION_DEFINITION, FRAGMENT_DEFINITION, VARIABLE} from 'graphql/language/kinds';
  2 | import {TypeKind} from 'graphql/type/introspection';
  3 | import {parse as gqlParse} from 'graphql/language/parser';
  4 | 
  5 | const {NON_NULL, UNION} = TypeKind;
  6 | 
  7 | export const TYPENAME = '__typename';
  8 | export const CASHAY = 'CASHAY';
  9 | export const DELIMITER = '_';
 10 | export const NORM_DELIMITER = '::';
 11 | export const REMOVAL_FLAG = '___CASHAY_REMOVAL_FLAG___';
 12 | 
 13 | /* redux store array constants */
 14 | export const FRONT = 'front';
 15 | export const BACK = 'back';
 16 | export const FULL = 'full';
 17 | 
 18 | /* subscription handler names */
 19 | export const ADD = 'add';
 20 | export const UPDATE = 'update';
 21 | export const UPSERT = 'upsert';
 22 | export const REMOVE = 'remove';
 23 | 
 24 | /* default pagination argsuments */
 25 | export const FIRST = 'first';
 26 | export const LAST = 'last';
 27 | export const BEFORE = 'before';
 28 | export const AFTER = 'after';
 29 | 
 30 | /* status for queries */
 31 | export const LOADING = 'loading';
 32 | export const COMPLETE = 'complete';
 33 | 
 34 | /* status for subscriptions */
 35 | export const SUBSCRIBING = 'subscribing';
 36 | export const READY = 'ready';
 37 | export const UNSUBSCRIBED = 'unsubscribed';
 38 | 
 39 | /* directives */
 40 | export const LIVE = 'live';
 41 | export const LOCAL_SORT = 'localSort';
 42 | export const LOCAL_FILTER = 'localFilter';
 43 | export const LOCAL = 'local';
 44 | export const CACHED = `cached`;
 45 | export const CACHED_ARGS = ['id', 'ids', 'type'];
 46 | 
 47 | 
 48 | export const ensureTypeFromNonNull = type => type.kind === NON_NULL ? type.ofType : type;
 49 | 
 50 | export const ensureRootType = type => {
 51 |   while (type.ofType) type = type.ofType;
 52 |   return type;
 53 | };
 54 | 
 55 | export const getRegularArgsKey = regularArgs => {
 56 |   return regularArgs && (Object.keys(regularArgs).length ? JSON.stringify(regularArgs) : '');
 57 | };
 58 | 
 59 | export const isObject = val => val && typeof val === 'object';
 60 | 
 61 | export const clone = obj => JSON.parse(JSON.stringify(obj));
 62 | 
 63 | // export const scalarSafeClone = maybeObj => isObject(maybeObj) ? clone(maybeObj) : maybeObj;
 64 | 
 65 | export const shallowPlus1Clone = obj => {
 66 |   if (!isObject(obj)) return obj;
 67 |   const dataKeys = Object.keys(obj);
 68 |   const newObj = {};
 69 |   for (let i = 0; i < dataKeys.length; i++) {
 70 |     const key = dataKeys[i];
 71 |     const prop = obj[key];
 72 |     let propClone = prop;
 73 |     if (Array.isArray(prop)) {
 74 |       propClone = prop.slice();
 75 |     } else if (isObject(prop)) {
 76 |       propClone = {...prop};
 77 |     }
 78 |     newObj[key] = propClone;
 79 |   }
 80 |   return newObj;
 81 | };
 82 | 
 83 | export const makeErrorFreeResponse = cachedResponse => {
 84 |   const {status, setVariables} = cachedResponse;
 85 |   return {
 86 |     data: shallowPlus1Clone(cachedResponse.data),
 87 |     setVariables,
 88 |     status
 89 |   }
 90 | };
 91 | 
 92 | export const checkMutationInSchema = (rootMutation, mutationName) => {
 93 |   const mutationSchema = rootMutation.fields[mutationName];
 94 |   if (!mutationSchema) {
 95 |     throw new Error(`Invalid mutation: ${mutationName}.
 96 |     Did you make a typo or forget to update your schema?`);
 97 |   }
 98 | };
 99 | 
100 | export const convertFragmentToInline = fragment => {
101 |   delete fragment.name;
102 |   fragment.kind = INLINE_FRAGMENT;
103 |   return fragment;
104 | };
105 | 
106 | export const parse = graphQLString => gqlParse(graphQLString, {noLocation: true, noSource: true});
107 | 
108 | export const buildExecutionContext = (queryAST, params) => {
109 |   const clonedAST = clone(queryAST);
110 |   const {operation, fragments} = teardownDocumentAST(clonedAST.definitions);
111 |   return {operation, fragments, ...params};
112 | };
113 | 
114 | export const teardownDocumentAST = astDefinitions => {
115 |   let operation;
116 |   const fragments = {};
117 |   for (let i = 0; i < astDefinitions.length; i++) {
118 |     const definition = astDefinitions[i];
119 |     if (definition.kind === OPERATION_DEFINITION) {
120 |       if (operation) {
121 |         throw new Error('Multiple operations not supported');
122 |       }
123 |       operation = definition;
124 |     } else if (definition.kind === FRAGMENT_DEFINITION) {
125 |       fragments[definition.name.value] = definition;
126 |     }
127 |   }
128 |   if (!operation) {
129 |     throw new Error('Must provide an operation.');
130 |   }
131 |   return {operation, fragments};
132 | };
133 | 
134 | /**
135 |  * stateVars is the name for the variables stored in the redux state, which are the most current variables for an op.
136 |  * @param {Object} cashayState the result of this.getState(), usually equivalent to store.getState().cashay
137 |  * @param {Object} op the name of the container full of keys
138 |  * @param {Object} key the key for the specified op, defaults to ''
139 |  * */
140 | export const getStateVars = (cashayState, op, key) => {
141 |   // explicitly return undefined so we can use default values in functions
142 |   return cashayState.ops[op] && cashayState.ops[op][key] && cashayState.ops[op][key].variables || undefined;
143 | };
144 | 
145 | export const getVariables = (initialVariables = {}, cashayState, op, key, cachedResponse) => {
146 |   const stateVars = getStateVars(cashayState, op, key) || {};
147 |   const newInitialVariables = resolveInitialVariables(cashayState, initialVariables, cachedResponse);
148 |   // make the stateVars override the likely stale UD vars, but if the UD vars have something that used to be undefined, keep it
149 |   return {...newInitialVariables, ...stateVars};
150 | };
151 | 
152 | const resolveInitialVariables = (cashayState, initialVariables, cachedResponse) => {
153 |   const variableNames = Object.keys(initialVariables);
154 |   const newVariables = {};
155 |   for (let i = 0; i < variableNames.length; i++) {
156 |     const variableName = variableNames[i];
157 |     const value = initialVariables[variableName];
158 |     newVariables[variableName] = (typeof value === 'function') ? safeValue(cachedResponse, value, cashayState) : value;
159 |   }
160 |   return newVariables;
161 | };
162 | 
163 | const safeValue = (response, cb, cashayState) => response && response.data && cb(response.data, cashayState);
164 | 
165 | export const makeNamespaceString = (op, name, d = DELIMITER) => `${CASHAY}${d}${op}${d}${name}`;
166 | 
167 | export const without = (obj, exclusions) => {
168 |   const objKeys = Object.keys(obj);
169 |   const newObj = {};
170 |   for (let i = 0; i < objKeys.length; i++) {
171 |     const key = objKeys[i];
172 |     if (!exclusions.includes(key)) {
173 |       newObj[key] = obj[key];
174 |     }
175 |   }
176 |   return newObj;
177 | };
178 | 
179 | export const isLive = (directives) => Boolean(directives && directives.find(d => d.name.value === LIVE));
180 | 
181 | export const getFieldSchema = (field, maybeTypeSchema, schema) => {
182 |   const fieldName = field.name.value;
183 |   const liveDirective = isLive(field.directives);
184 |   const typeSchema = liveDirective ? schema.subscriptionSchema : maybeTypeSchema;
185 |   const fieldSchema = typeSchema.fields[fieldName];
186 |   if (!fieldSchema) {
187 |     throw new Error(`${fieldName} isn't in the schema. Did you update your client schema?`)
188 |   }
189 |   return fieldSchema;
190 | };
191 | 
192 | export const defaultResolveChannelKeyFactory = (idFieldName, topLevelSource) => (source, args) => {
193 |   if (!topLevelSource) {
194 |     return source[idFieldName] || '';
195 |   } else {
196 |     return args[idFieldName] ? args[idFieldName] : args[Object.keys(args)[0]] || '';
197 |   }
198 | };
199 | 
200 | export const makeFullChannel = (channel, channelKey) => {
201 |   return channelKey ? `${channel}${NORM_DELIMITER}${channelKey}` : channel;
202 | };
203 | 
204 | export const makeCachedArgs = (argsArr, variables, schema) => {
205 |   const cachedArgs = {};
206 |   for (let i = 0; i < argsArr.length; i++) {
207 |     const arg = argsArr[i];
208 |     const argName = arg.name.value;
209 |     cachedArgs[argName] = getVariableValue(arg, variables);
210 |   }
211 |   if (cachedArgs.id && typeof cachedArgs.id !== 'string') {
212 |     throw new Error(`@cached 'id' arg requires a string`)
213 |   }
214 |   if (cachedArgs.ids && !Array.isArray(cachedArgs.ids)) {
215 |     throw new Error(`@cached 'ids' arg requires an array`)
216 |   }
217 |   const {type} = parseCachedType(cachedArgs.type);
218 |   const typeSchema = schema.types[type];
219 |   if (!typeSchema) {
220 |     throw new Error(`@cached type ${type} does not exist in your schema!`);
221 |   }
222 |   return cachedArgs;
223 | };
224 | 
225 | export const getVariableValue = (arg, variables) => {
226 |   return arg.value.kind === VARIABLE ? variables[arg.value.name.value] : arg.value.value;
227 | };
228 | 
229 | export const getTypeName = (typeSchema, updatedData, doc) => {
230 |   if (typeSchema.kind === UNION) {
231 |     const typeName = updatedData.__typename;
232 |     if (!typeName) {
233 |       throw new Error(`Cannot determine typeName for incoming document ${doc}.`)
234 |     }
235 |     return typeName;
236 |   }
237 |   return typeSchema.name;
238 | };
239 | 
240 | export const shallowEqual = (obj1, obj2) => {
241 |   // obj1 is guaranteed to be different than obj2, so no need to check strict eq
242 |   const obj1Keys = Object.keys(obj1);
243 |   const obj2Keys = Object.keys(obj2);
244 |   if (obj1Keys.length !== obj2Keys.length) return false;
245 |   for (let i = 0; i < obj1Keys.length; i++) {
246 |     const key = obj1Keys[i];
247 |     if (obj1[key] !== obj2[key]) return false;
248 |   }
249 |   return true;
250 | };
251 | 
252 | export const parseCachedType = (type) => {
253 |   if (type.startsWith('[')) {
254 |     return {
255 |       type: type.substr(1,type.length-2),
256 |       typeIsList: true
257 |     }
258 |   } else {
259 |     return {
260 |       type,
261 |       typeIsList: false
262 |     }
263 |   }
264 | };
265 | 


--------------------------------------------------------------------------------