Initial commit

.gitignore

@@ -0,0 +1,2 @@
+lib
+node_modules

.npmignore

@@ -0,0 +1 @@
+src

LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Denis Nedelyaev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package.json

@@ -0,0 +1,35 @@
+{
+  "name": "isomorphic-relay",
+  "version": "0.1.0",
+  "description": "Adds server side rendering support to React Relay",
+  "author": "Denis Nedelyaev",
+  "homepage": "https://github.com/denvned/isomorphic-relay",
+  "bugs": {
+    "url": "https://github.com/denvned/isomorphic-relay/issues"
+  },
+  "license": "BSD-2-Clause",
+  "keywords": [
+    "isomorphic",
+    "isomorphic-react-relay",
+    "isomorphic-relay",
+    "react",
+    "react-relay",
+    "relay",
+    "server",
+    "server-rendering",
+    "server-side",
+    "server-side-rendering"
+  ],
+  "main": "lib/IsomorphicRelay.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/denvned/isomorphic-relay.git"
+  },
+  "scripts": {
+    "build": "babel src --out-dir lib",
+    "prepublish": "npm run build"
+  },
+  "peerDependencies": {
+    "react-relay": "0.4.0"
+  }
+}

src/InterceptingNetworkLayer.js

@@ -0,0 +1,27 @@
+import Relay from 'react-relay/lib/RelayPublic';
+
+export const queryResults = new WeakMap();
+
+const interceptingNetworkLayer = {
+    sendQueries(requests) {
+        requests.forEach(request => {
+            request.then(({response}) => {
+                queryResults.set(request.getQuery(), response);
+            });
+        });
+        return super.sendQueries(requests);
+    }
+};
+
+let _wasInjected = false;
+
+export function wasInjected() {
+    return _wasInjected;
+}
+
+export function injectNetworkLayerOnServer(networkLayer) {
+    Object.setPrototypeOf(interceptingNetworkLayer, networkLayer);
+
+    Relay.injectNetworkLayer(interceptingNetworkLayer);
+    _wasInjected = true;
+}

src/IsomorphicRelay.js

@@ -0,0 +1,4 @@
+export {injectNetworkLayerOnServer} from './InterceptingNetworkLayer'
+export {default as IsomorphicRootContainer} from './IsomorphicRootContainer'
+export {default as loadAndStoreData} from './loadAndStoreData'
+export {default as storePreloadedData} from './storePreloadedData'

src/IsomorphicRootContainer.js

@@ -0,0 +1,76 @@
+import GraphQLFragmentPointer from 'react-relay/lib/GraphQLFragmentPointer';
+import Relay from 'react-relay/lib/RelayPublic';
+import RelayQuery from 'react-relay/lib/RelayQuery';
+import RelayStoreData from 'react-relay/lib/RelayStoreData';
+
+export default class IsomorphicRootContainer extends Relay.RootContainer {
+    _runQueries(props) {
+        // _runQueries should not be called on server side,
+        // so don't call it from constructor, and call it from componentDidMount instead
+        return this.state ?
+            super._runQueries(props) :
+            createInitialState(props);
+    }
+
+    componentDidMount() {
+        if ((!this.state.readyState || this.props.forceFetch) && !this.state.pendingRequest) {
+            this.setState(super._runQueries(this.props));
+        }
+    }
+}
+
+function createInitialState({Component, forceFetch, route}) {
+    const querySet = Relay.getQueries(Component, route);
+    const fragmentPointers = createFragmentPointersForRoots(querySet);
+
+    return isDataReady(querySet, fragmentPointers) ? {
+        activeComponent: Component,
+        activeRoute: route,
+        error: null,
+        fetchState: {
+            done: true,
+            stale: forceFetch,
+        },
+        fragmentPointers,
+        pendingRequest: null,
+        readyState: {
+            aborted: false,
+            done: true,
+            error: null,
+            mounted: true,
+            ready: true,
+            stale: forceFetch,
+        },
+    } : {
+        activeComponent: null,
+        activeRoute: null,
+        error: null,
+        fetchState: {
+            done: false,
+            stale: false,
+        },
+        fragmentPointers: null,
+        pendingRequest: null,
+        readyState: null,
+    };
+}
+
+const queuedStore = RelayStoreData.getDefaultInstance().getQueuedStore();
+
+function createFragmentPointersForRoots(querySet) {
+    const fragmentPointers = {};
+
+    Object.keys(querySet).forEach(name => {
+        fragmentPointers[name] = createFragmentPointerForRoot(querySet[name]);
+    });
+    return fragmentPointers;
+}
+
+const createFragmentPointerForRoot = query => query ?
+    GraphQLFragmentPointer.createForRoot(queuedStore, query) :
+    null;
+
+const isDataReady = (querySet, fragmentPointers) =>
+    Object.keys(querySet).every(name => fragmentPointers[name] || !queryHasRootFragment(querySet[name]));
+
+const queryHasRootFragment = query => query && query.getChildren().some(child => child instanceof RelayQuery.Fragment);

src/loadAndStoreData.js

@@ -0,0 +1,37 @@
+import Relay from 'react-relay/lib/RelayPublic';
+import {
+    queryResults,
+    wasInjected,
+} from './InterceptingNetworkLayer';
+
+export default function({Component, route}) {
+    if (!wasInjected()) {
+        throw new Error('NetworkLayer was not injected!');
+    }
+    return new Promise((resolve, reject) => {
+        const querySet = Relay.getQueries(Component, route);
+
+        Relay.Store.forceFetch(querySet, ({aborted, done, error, stale}) => {
+            if (error) {
+                reject(error);
+            } else if (aborted) {
+                reject(new Error('Aborted'));
+            } else if (done && !stale) {
+                resolve(getQueryResults());
+            }
+        });
+
+        function getQueryResults() {
+            const results = {};
+
+            Object.keys(querySet).forEach(name => {
+                const result = queryResults.get(querySet[name]);
+                if (!result) {
+                    throw new Error(`No result for query "${name}"`);
+                }
+                results[name] = result;
+            });
+            return results;
+        }
+    });
+}

src/storePreloadedData.js

@@ -0,0 +1,28 @@
+import DliteFetchModeConstants from 'react-relay/lib/DliteFetchModeConstants';
+import GraphQLQueryRunner from 'react-relay/lib/GraphQLQueryRunner';
+import Relay from 'react-relay/lib/RelayPublic';
+import RelayPendingQueryTracker from 'react-relay/lib/RelayPendingQueryTracker';
+
+export default function({Component, route}, queryResults) {
+    const querySet = Relay.getQueries(Component, route);
+
+    const request = new Promise((resolve, reject) => {
+        GraphQLQueryRunner.run(querySet, ({aborted, done, error}) => {
+            if (error) {
+                reject(error);
+            } else if (aborted) {
+                reject(new Error('Aborted'));
+            } else if (done) {
+                resolve();
+            }
+        }, DliteFetchModeConstants.FETCH_MODE_PRELOAD);
+    });
+    Object.keys(querySet).forEach(name => {
+        const result = queryResults[name];
+        if (!result) {
+            throw new Error(`No result for query "${name}"`);
+        }
+        RelayPendingQueryTracker.resolvePreloadQuery(querySet[name].getID(), { response: result });
+    });
+    return request;
+}