including CAIT data, models and seeds

data/schema.js

@@ -0,0 +1,143 @@
+/**
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString,
+} from 'graphql';
+
+import {
+  connectionArgs,
+  connectionDefinitions,
+  connectionFromArray,
+  fromGlobalId,
+  globalIdField,
+  mutationWithClientMutationId,
+  nodeDefinitions,
+} from 'graphql-relay';
+
+import {
+  // Import methods that your schema can use to interact with your database
+  User,
+  Widget,
+  getUser,
+  getViewer,
+  getWidget,
+  getWidgets,
+} from './database';
+
+/**
+ * We get the node interface and field from the Relay library.
+ *
+ * The first method defines the way we resolve an ID to its object.
+ * The second defines the way we resolve an object to its GraphQL type.
+ */
+var {nodeInterface, nodeField} = nodeDefinitions(
+  (globalId) => {
+    var {type, id} = fromGlobalId(globalId);
+    if (type === 'User') {
+      return getUser(id);
+    } else if (type === 'Widget') {
+      return getWidget(id);
+    } else {
+      return null;
+    }
+  },
+  (obj) => {
+    if (obj instanceof User) {
+      return userType;
+    } else if (obj instanceof Widget)  {
+      return widgetType;
+    } else {
+      return null;
+    }
+  }
+);
+
+/**
+ * Define your own types here
+ */
+
+var userType = new GraphQLObjectType({
+  name: 'User',
+  description: 'A person who uses our app',
+  fields: () => ({
+    id: globalIdField('User'),
+    widgets: {
+      type: widgetConnection,
+      description: 'A person\'s collection of widgets',
+      args: connectionArgs,
+      resolve: (_, args) => connectionFromArray(getWidgets(), args),
+    },
+  }),
+  interfaces: [nodeInterface],
+});
+
+var widgetType = new GraphQLObjectType({
+  name: 'Widget',
+  description: 'A shiny widget',
+  fields: () => ({
+    id: globalIdField('Widget'),
+    name: {
+      type: GraphQLString,
+      description: 'The name of the widget',
+    },
+  }),
+  interfaces: [nodeInterface],
+});
+
+/**
+ * Define your own connection types here
+ */
+var {connectionType: widgetConnection} =
+  connectionDefinitions({name: 'Widget', nodeType: widgetType});
+
+/**
+ * This is the type that will be the root of our query,
+ * and the entry point into our schema.
+ */
+var queryType = new GraphQLObjectType({
+  name: 'Query',
+  fields: () => ({
+    node: nodeField,
+    // Add your own root fields here
+    viewer: {
+      type: userType,
+      resolve: () => getViewer(),
+    },
+  }),
+});
+
+/**
+ * This is the type that will be the root of our mutations,
+ * and the entry point into performing writes in our schema.
+ */
+var mutationType = new GraphQLObjectType({
+  name: 'Mutation',
+  fields: () => ({
+    // Add your own mutations here
+  })
+});
+
+/**
+ * Finally, we construct our schema (whose starting query type is the query
+ * type we defined above) and export it.
+ */
+export var Schema = new GraphQLSchema({
+  query: queryType,
+  // Uncomment the following after adding some mutation fields:
+  // mutation: mutationType
+});