@orion-js/graphql 2.2.0

package/lib/getApolloOptions/formatError.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _default(apolloError) {
+  let response = { ...apolloError
+  };
+  const error = apolloError.originalError;
+
+  if (error && error.isValidationError) {
+    response.validationErrors = error.validationErrors;
+  }
+
+  if (error && error.getInfo) {
+    response = error.getInfo();
+  }
+
+  return response;
+}

package/lib/getApolloOptions/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _buildSchema = _interopRequireDefault(require("../buildSchema"));
+
+var _formatError = _interopRequireDefault(require("./formatError"));
+
+async function _default(options) {
+  const schema = await (0, _buildSchema.default)(options);
+  return {
+    endpointURL: '/graphql',
+    subscriptionsEndpoint: `/subscriptions`,
+    schema,
+    formatError: _formatError.default,
+    useGraphiql: options.useGraphiql || true,
+    context: integrationContext => {
+      return integrationContext.req._orionjsViewer;
+    },
+    ...options
+  };
+}

package/lib/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "subscription", {
+  enumerable: true,
+  get: function () {
+    return _subscription.default;
+  }
+});
+Object.defineProperty(exports, "startGraphQL", {
+  enumerable: true,
+  get: function () {
+    return _startGraphQL.default;
+  }
+});
+Object.defineProperty(exports, "startGraphiQL", {
+  enumerable: true,
+  get: function () {
+    return _startGraphiQL.default;
+  }
+});
+Object.defineProperty(exports, "resolversSchemas", {
+  enumerable: true,
+  get: function () {
+    return _resolversSchemas.default;
+  }
+});
+Object.defineProperty(exports, "ResolverParams", {
+  enumerable: true,
+  get: function () {
+    return _ResolverParams.default;
+  }
+});
+Object.defineProperty(exports, "serializeSchema", {
+  enumerable: true,
+  get: function () {
+    return _serializeSchema.default;
+  }
+});
+Object.defineProperty(exports, "getBasicResultQuery", {
+  enumerable: true,
+  get: function () {
+    return _getBasicResultQuery.default;
+  }
+});
+exports.GraphQL = void 0;
+
+var _subscription = _interopRequireDefault(require("./subscription"));
+
+var _startGraphQL = _interopRequireDefault(require("./startGraphQL"));
+
+var _startGraphiQL = _interopRequireDefault(require("./startGraphiQL"));
+
+var _resolversSchemas = _interopRequireDefault(require("./resolversSchemas"));
+
+var _ResolverParams = _interopRequireDefault(require("./resolversSchemas/ResolverParams"));
+
+var _serializeSchema = _interopRequireDefault(require("./resolversSchemas/serializeSchema"));
+
+var _getBasicResultQuery = _interopRequireDefault(require("./resolversSchemas/getBasicResultQuery"));
+
+var GraphQL = _interopRequireWildcard(require("graphql"));
+
+exports.GraphQL = GraphQL;

package/lib/pubsub.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPubsub = exports.setPubsub = void 0;
+let pubsub = null;
+
+const setPubsub = function (newPubsub) {
+  pubsub = newPubsub;
+};
+
+exports.setPubsub = setPubsub;
+
+const getPubsub = function () {
+  return pubsub;
+};
+
+exports.getPubsub = getPubsub;

package/lib/resolversSchemas/ResolverParams.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _serializeSchema = _interopRequireDefault(require("./serializeSchema"));
+
+var _getBasicResultQuery = _interopRequireDefault(require("./getBasicResultQuery"));
+
+var _app = require("@orion-js/app");
+
+var _default = new _app.Model({
+  name: 'ResolverParams',
+  schema: {
+    name: {
+      type: String
+    }
+  },
+  resolvers: {
+    params: (0, _app.resolver)({
+      returns: 'blackbox',
+      resolve: async function ({
+        resolver
+      }) {
+        return await (0, _serializeSchema.default)(resolver.params);
+      }
+    }),
+    result: (0, _app.resolver)({
+      returns: String,
+      resolve: async function ({
+        resolver
+      }) {
+        return resolver.returns.name;
+      }
+    }),
+    basicResultQuery: (0, _app.resolver)({
+      returns: String,
+      resolve: async function ({
+        resolver
+      }) {
+        return await (0, _getBasicResultQuery.default)({
+          type: resolver.returns.schema
+        });
+      }
+    })
+  }
+});
+
+exports.default = _default;

package/lib/resolversSchemas/getBasicResultQuery.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getBasicQuery;
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+async function getBasicQuery(field) {
+  if (!field.type) return '';
+
+  if ((0, _isArray.default)(field.type) && field.type[0].__model || field.type.__model) {
+    const model = (0, _isArray.default)(field.type) ? field.type[0].__model : field.type.__model;
+    const fields = [];
+
+    for (const field of model.staticFields) {
+      fields.push(await getBasicQuery(field));
+    }
+
+    const key = field.key ? `${field.key} ` : '';
+    return `${key}{ ${fields.join(' ')} }`;
+  } else {
+    return field.key;
+  }
+}

package/lib/resolversSchemas/getField.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getParams;
+
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _schema = require("@orion-js/schema");
+
+var _omit = _interopRequireDefault(require("lodash/omit"));
+
+var _getScalar = _interopRequireDefault(require("../buildSchema/getType/getScalar"));
+
+async function getParams(field) {
+  const {
+    type
+  } = field;
+
+  if ((0, _isArray.default)(type)) {
+    const serialized = await getParams({ ...field,
+      type: type[0]
+    });
+    return { ...serialized,
+      type: [serialized.type],
+      __graphQLType: `[${serialized.__graphQLType}]`
+    };
+  } else if (!type._isFieldType && ((0, _isPlainObject.default)(type) || type.__isModel)) {
+    const model = type.__isModel ? type : type.__model;
+    if (!model || !model.__isModel) throw new Error('Type if not a Model', type);
+    const fields = {};
+
+    for (const field of model.staticFields) {
+      fields[field.key] = await getParams(field);
+    }
+
+    return { ...(0, _omit.default)(field, 'key'),
+      type: fields,
+      __graphQLType: model.name + 'Input'
+    };
+  } else {
+    const schemaType = await (0, _schema.getFieldType)(type);
+    const graphQLType = await (0, _getScalar.default)(schemaType);
+    return { ...(0, _omit.default)(field, 'key'),
+      type: schemaType.name,
+      __graphQLType: graphQLType.name
+    };
+  }
+}

package/lib/resolversSchemas/getField.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _getField = _interopRequireDefault(require("./getField"));
+
+it('should return a valid serialization of the field', async () => {
+  const schema = {
+    name: {
+      type: String,
+      a: '1234'
+    }
+  };
+  const result = await (0, _getField.default)(schema.name);
+  expect(result).toEqual({
+    type: 'string',
+    a: '1234',
+    __graphQLType: 'String'
+  });
+});
+it('should pass field options with simple array fields', async () => {
+  const schema = {
+    name: {
+      type: [String],
+      a: '1234'
+    }
+  };
+  const result = await (0, _getField.default)(schema.name);
+  expect(result.a).toEqual(schema.name.a);
+});

package/lib/resolversSchemas/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _params = _interopRequireDefault(require("./params"));
+
+var _default = {
+  params: _params.default
+};
+exports.default = _default;

package/lib/resolversSchemas/params.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _app = require("@orion-js/app");
+
+var _ResolverParams = _interopRequireDefault(require("./ResolverParams"));
+
+var _default = (0, _app.resolver)({
+  params: {
+    name: {
+      type: 'ID'
+    },
+    mutation: {
+      type: Boolean
+    }
+  },
+  returns: _ResolverParams.default,
+  mutation: false,
+  resolve: async function ({
+    mutation,
+    name
+  }, viewer) {
+    const resolver = global.graphQLResolvers[name];
+
+    if (!resolver) {
+      throw new _app.UserError('notFound', `${mutation ? 'Mutation' : 'Query'} named "${name}" not found`);
+    }
+
+    if (!!resolver.mutation !== !!mutation) {
+      throw new _app.UserError('incorrectType', `"${name}" is ${mutation ? 'not' : ''} a mutation`);
+    }
+
+    return {
+      resolver,
+      name
+    };
+  }
+});
+
+exports.default = _default;

package/lib/resolversSchemas/serializeSchema.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = serializeSchema;
+
+var _getField = _interopRequireDefault(require("./getField"));
+
+async function serializeSchema(params) {
+  if (!params) return;
+  if (Object.keys(params).length === 0) return;
+  const fields = {};
+
+  for (const key of Object.keys(params)) {
+    const field = params[key];
+    fields[key] = await (0, _getField.default)(field);
+  }
+
+  return fields;
+}

package/lib/resolversSchemas/serializeSchema.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _serializeSchema = _interopRequireDefault(require("./serializeSchema"));
+
+it('should create a JSON of the schema', async () => {
+  const schema = {
+    name: {
+      type: String
+    }
+  };
+  const result = await (0, _serializeSchema.default)(schema);
+  expect(result).toEqual({
+    name: {
+      type: 'string',
+      __graphQLType: 'String'
+    }
+  });
+});
+it('should pass field options', async () => {
+  const schema = {
+    name: {
+      type: [String],
+      a: '1234'
+    }
+  };
+  const result = await (0, _serializeSchema.default)(schema);
+  expect(result.name.a).toEqual(schema.name.a);
+});

package/lib/startGraphQL.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _app = require("@orion-js/app");
+
+var _apolloServerMicro = require("apollo-server-micro");
+
+var _startGraphiQL = _interopRequireDefault(require("./startGraphiQL"));
+
+var _getApolloOptions = _interopRequireDefault(require("./getApolloOptions"));
+
+var _startWebsocket = _interopRequireDefault(require("./startWebsocket"));
+
+var _micro = _interopRequireDefault(require("micro"));
+
+var _apolloServerCore = require("apollo-server-core");
+
+global.globalMicro = _micro.default;
+
+async function _default(options) {
+  const apolloOptions = await (0, _getApolloOptions.default)(options);
+  (0, _startGraphiQL.default)(apolloOptions, options);
+
+  if (options.subscriptions) {
+    (0, _startWebsocket.default)(apolloOptions, options);
+  }
+
+  const apolloServer = new _apolloServerMicro.ApolloServer(apolloOptions);
+  const handler = apolloServer.createHandler(); // highlight-line
+
+  (0, _app.route)('/graphql', async function (params) {
+    const {
+      request,
+      response,
+      viewer,
+      getBodyJSON
+    } = params;
+
+    if (options.executeGraphQLCache) {
+      try {
+        // this returns the original not-cached answer
+        const fallback = async () => {
+          const data = await getBodyJSON();
+          const gqlResponse = await (0, _apolloServerCore.runHttpQuery)([request, response], {
+            method: request.method,
+            options: { ...apolloOptions,
+              context: viewer
+            },
+            query: data
+          });
+          return gqlResponse.graphqlResponse;
+        };
+
+        const result = await options.executeGraphQLCache(params, fallback);
+
+        if (result) {
+          return result;
+        }
+      } catch (error) {
+        console.log('Error executing GraphQL cache:', error);
+      }
+    }
+
+    request._orionjsViewer = viewer;
+    handler(request, response);
+  });
+}