@orion-js/graphql 2.2.0

package/LICENSE

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

package/lib/buildSchema/getArgs/getField.js

@@ -0,0 +1,61 @@
+"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 _graphql = require("graphql");
+
+var _schema = require("@orion-js/schema");
+
+var _app = require("@orion-js/app");
+
+var _getScalar = _interopRequireDefault(require("../getType/getScalar"));
+
+const storedModelInput = {};
+
+const getModelInput = function (model, fields) {
+  if (storedModelInput[model.name]) {
+    return storedModelInput[model.name];
+  }
+
+  storedModelInput[model.name] = new _graphql.GraphQLInputObjectType({
+    name: model.name + 'Input',
+    fields
+  });
+  return storedModelInput[model.name];
+};
+
+function getParams(type) {
+  if (!type) {
+    throw new Error(`No type specified`);
+  }
+
+  if ((0, _isArray.default)(type)) {
+    const graphQLType = getParams(type[0]);
+    return new _graphql.GraphQLList(graphQLType);
+  } else if (!type._isFieldType && ((0, _isPlainObject.default)(type) || type instanceof _app.Model)) {
+    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] = {
+        type: getParams(field.type)
+      };
+    }
+
+    return getModelInput(model, fields);
+  } else {
+    const schemaType = (0, _schema.getFieldType)(type);
+    const graphQLType = (0, _getScalar.default)(schemaType);
+    return graphQLType;
+  }
+}

package/lib/buildSchema/getArgs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _getField = _interopRequireDefault(require("./getField"));
+
+var _app = require("@orion-js/app");
+
+function _default(params) {
+  const {
+    logger
+  } = (0, _app.config)();
+  if (!params) return;
+  if (Object.keys(params).length === 0) return;
+  const fields = {};
+
+  for (const key of Object.keys(params)) {
+    try {
+      const type = (0, _getField.default)(params[key].type);
+      fields[key] = {
+        type
+      };
+    } catch (error) {
+      logger.error(`Error creating GraphQL resolver params argument ${key}`, error);
+    }
+  }
+
+  return fields;
+}

package/lib/buildSchema/getMutation.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _graphql = require("graphql");
+
+var _getResolvers = _interopRequireDefault(require("./getResolvers"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+async function _default({
+  resolvers,
+  ...options
+}) {
+  const fields = await (0, _getResolvers.default)({
+    resolvers,
+    mutation: true,
+    options
+  });
+  if ((0, _isEmpty.default)(fields)) return null;
+  return new _graphql.GraphQLObjectType({
+    name: 'Mutation',
+    fields
+  });
+}

package/lib/buildSchema/getQuery.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _graphql = require("graphql");
+
+var _getResolvers = _interopRequireDefault(require("./getResolvers"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+async function _default({
+  resolvers,
+  ...options
+}) {
+  const fields = await (0, _getResolvers.default)({
+    resolvers,
+    mutation: false,
+    options
+  });
+  if ((0, _isEmpty.default)(fields)) return null;
+  return new _graphql.GraphQLObjectType({
+    name: 'Query',
+    fields
+  });
+}

package/lib/buildSchema/getResolvers/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _getType = _interopRequireDefault(require("../getType"));
+
+var _getArgs = _interopRequireDefault(require("../getArgs"));
+
+var _errorHandler = _interopRequireDefault(require("../../errorHandler"));
+
+global.graphQLResolvers = {};
+
+async function _default({
+  resolvers,
+  mutation,
+  options
+}) {
+  const filteredResolvers = Object.keys(resolvers).map(key => {
+    return {
+      name: key,
+      resolver: resolvers[key]
+    };
+  }).filter(({
+    resolver
+  }) => !!resolver.mutation === !!mutation).filter(({
+    resolver
+  }) => !resolver.private);
+  const fields = {};
+
+  for (const {
+    resolver,
+    name
+  } of filteredResolvers) {
+    global.graphQLResolvers[name] = resolver;
+    const type = await (0, _getType.default)(resolver.returns, options);
+    const args = await (0, _getArgs.default)(resolver.params);
+    fields[name] = {
+      type,
+      args,
+
+      async resolve(root, params, context) {
+        try {
+          const result = await resolver(params, context);
+          return result;
+        } catch (error) {
+          (0, _errorHandler.default)(error, {
+            context,
+            resolver,
+            options,
+            name
+          });
+          throw error;
+        }
+      }
+
+    };
+  }
+
+  return fields;
+}

package/lib/buildSchema/getSubscription.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _graphql = require("graphql");
+
+var _getSubscriptions = _interopRequireDefault(require("./getSubscriptions"));
+
+async function _default({
+  subscriptions,
+  ...options
+}) {
+  if (!subscriptions) return null;
+  const fields = await (0, _getSubscriptions.default)({
+    subscriptions,
+    options
+  });
+  return new _graphql.GraphQLObjectType({
+    name: 'Subscription',
+    fields
+  });
+}

package/lib/buildSchema/getSubscriptions/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _getType = _interopRequireDefault(require("../getType"));
+
+var _getArgs = _interopRequireDefault(require("../getArgs"));
+
+global.graphQLSubscriptions = {};
+
+async function _default({
+  subscriptions,
+  options
+}) {
+  const fields = {};
+
+  for (const key of Object.keys(subscriptions)) {
+    const subscription = subscriptions[key];
+    global.graphQLSubscriptions[key] = subscription;
+    subscription.key = key;
+    const name = key;
+    global.graphQLSubscriptions[name] = subscription;
+    const type = await (0, _getType.default)(subscription.returns, options);
+    const args = await (0, _getArgs.default)(subscription.params);
+    fields[name] = {
+      type,
+      args,
+
+      async subscribe(root, params, viewer) {
+        return await subscription.subscribe(params, viewer);
+      }
+
+    };
+  }
+
+  return fields;
+}

package/lib/buildSchema/getType/BigIntScalar.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _graphql = require("graphql");
+
+const MAX_INT = Number.MAX_SAFE_INTEGER;
+const MIN_INT = Number.MIN_SAFE_INTEGER;
+
+const coerceBigInt = function coerceBigInt(value) {
+  if (value === '') {
+    throw new TypeError('BigInt cannot represent non 53-bit signed integer value: (empty string)');
+  }
+
+  const num = Number(value);
+
+  if (num > MAX_INT || num < MIN_INT) {
+    throw new TypeError('BigInt cannot represent non 53-bit signed integer value: ' + String(value));
+  }
+
+  const int = Math.floor(num);
+
+  if (int !== num) {
+    throw new TypeError('BigInt cannot represent non-integer value: ' + String(value));
+  }
+
+  return int;
+};
+
+var _default = new _graphql.GraphQLScalarType({
+  name: 'BigInt',
+  description: 'The `BigInt` scalar type represents non-fractional signed whole numeric ' + 'values. BigInt can represent values between -(2^53) + 1 and 2^53 - 1. ',
+  serialize: coerceBigInt,
+  parseValue: coerceBigInt,
+
+  parseLiteral(ast) {
+    if (ast.kind === 'IntValue') {
+      const num = parseInt(ast.value, 10);
+
+      if (num <= MAX_INT && num >= MIN_INT) {
+        return num;
+      }
+    }
+
+    return null;
+  }
+
+});
+
+exports.default = _default;

package/lib/buildSchema/getType/DateScalar.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _graphql = require("graphql");
+
+var _graphqlIsoDate = require("graphql-iso-date");
+
+var _default = new _graphql.GraphQLScalarType({
+  name: 'Date',
+  serialize: _graphqlIsoDate.GraphQLDateTime.serialize,
+  parseValue: _graphqlIsoDate.GraphQLDateTime.parseValue,
+  parseLiteral: _graphqlIsoDate.GraphQLDateTime.parseLiteral
+});
+
+exports.default = _default;

package/lib/buildSchema/getType/JSONScalar.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _graphql = require("graphql");
+
+function identity(value) {
+  return value;
+}
+
+function parseLiteral(ast, variables) {
+  switch (ast.kind) {
+    case _graphql.Kind.STRING:
+    case _graphql.Kind.BOOLEAN:
+      return ast.value;
+
+    case _graphql.Kind.INT:
+    case _graphql.Kind.FLOAT:
+      return parseFloat(ast.value);
+
+    case _graphql.Kind.OBJECT:
+      {
+        const value = Object.create(null);
+        ast.fields.forEach(field => {
+          value[field.name.value] = parseLiteral(field.value, variables);
+        });
+        return value;
+      }
+
+    case _graphql.Kind.LIST:
+      return ast.values.map(n => parseLiteral(n, variables));
+
+    case _graphql.Kind.NULL:
+      return null;
+
+    case _graphql.Kind.VARIABLE:
+      {
+        const name = ast.name.value;
+        return variables ? variables[name] : undefined;
+      }
+
+    default:
+      return undefined;
+  }
+}
+
+var _default = new _graphql.GraphQLScalarType({
+  name: 'JSON',
+  description: 'The `JSON` scalar type represents JSON values as specified by ' + '[ECMA-404](http://www.ecma-international.org/' + 'publications/files/ECMA-ST/ECMA-404.pdf).',
+  serialize: identity,
+  parseValue: identity,
+  parseLiteral
+});
+
+exports.default = _default;

package/lib/buildSchema/getType/getScalar.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _BigIntScalar = _interopRequireDefault(require("./BigIntScalar"));
+
+var _DateScalar = _interopRequireDefault(require("./DateScalar"));
+
+var _JSONScalar = _interopRequireDefault(require("./JSONScalar"));
+
+var _graphql = require("graphql");
+
+const fieldMap = {
+  string: _graphql.GraphQLString,
+  email: _graphql.GraphQLString,
+  date: _DateScalar.default,
+  integer: _BigIntScalar.default,
+  number: _graphql.GraphQLFloat,
+  ID: _graphql.GraphQLID,
+  boolean: _graphql.GraphQLBoolean,
+  blackbox: _JSONScalar.default
+};
+
+function _default(fieldType) {
+  if (fieldMap[fieldType.name]) {
+    return fieldMap[fieldType.name];
+  }
+
+  if (fieldType.toGraphQLType) {
+    const result = fieldType.toGraphQLType();
+
+    if (result.then) {
+      throw new Error('toGraphQLType cant return a promise');
+    }
+
+    return result;
+  }
+
+  throw new Error(`Field type "${fieldType.name}" has no convertion to GraphQLType`);
+}

package/lib/buildSchema/getType/getTypeAsResolver.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _getArgs = _interopRequireDefault(require("../getArgs"));
+
+var _errorHandler = _interopRequireDefault(require("../../errorHandler"));
+
+function _default({
+  resolver,
+  getGraphQLType,
+  options,
+  model
+}) {
+  const type = getGraphQLType(resolver.returns, options);
+  const args = (0, _getArgs.default)(resolver.params);
+  return {
+    type,
+    args,
+
+    async resolve(item, params, context) {
+      try {
+        const result = await resolver.resolve(item, params, context);
+        return result;
+      } catch (error) {
+        (0, _errorHandler.default)(error, {
+          context,
+          resolver,
+          options,
+          model
+        });
+        throw error;
+      }
+    }
+
+  };
+}

package/lib/buildSchema/getType/index.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getGraphQLType;
+
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _graphql = require("graphql");
+
+var _schema = require("@orion-js/schema");
+
+var _app = require("@orion-js/app");
+
+var _getScalar = _interopRequireDefault(require("./getScalar"));
+
+var _getTypeAsResolver = _interopRequireDefault(require("./getTypeAsResolver"));
+
+function getGraphQLType(type, options) {
+  if (!type) {
+    throw new Error('Type is undefined');
+  }
+
+  if ((0, _isArray.default)(type)) {
+    const graphQLType = getGraphQLType(type[0], options);
+    return new _graphql.GraphQLList(graphQLType);
+  } else if (!type._isFieldType && ((0, _isPlainObject.default)(type) || type instanceof _app.Model)) {
+    const model = type.__isModel ? type : type.__model;
+    if (!model || !model.__isModel) throw new Error('Type if not a Model', type);
+    if (model.graphQLType) return model.graphQLType;
+    model.graphQLType = new _graphql.GraphQLObjectType({
+      name: model.name,
+      fields: () => {
+        const fields = {};
+
+        for (const field of model.staticFields) {
+          try {
+            /**
+             * For fields that have custom "to client" resolvers and serverside are static
+             */
+            if (field.graphQLResolver) {
+              fields[field.key] = (0, _getTypeAsResolver.default)({
+                resolver: field.graphQLResolver,
+                getGraphQLType,
+                options,
+                model
+              });
+            } else {
+              fields[field.key] = {
+                type: getGraphQLType(field.type, options)
+              };
+            }
+          } catch (error) {
+            throw new Error(`Error getting type for ${field.key} ${error.message}`);
+          }
+        }
+
+        for (const resolver of model.dynamicFields) {
+          try {
+            fields[resolver.key] = (0, _getTypeAsResolver.default)({
+              resolver,
+              getGraphQLType,
+              options,
+              model
+            });
+          } catch (error) {
+            throw new Error(`Error getting resolver type for resolver "${resolver.key}": ${error.message}`);
+          }
+        }
+
+        return fields;
+      }
+    });
+    return model.graphQLType;
+  } else {
+    const schemaType = (0, _schema.getFieldType)(type);
+    const graphQLType = (0, _getScalar.default)(schemaType);
+    return graphQLType;
+  }
+}

package/lib/buildSchema/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _graphql = require("graphql");
+
+var _getQuery = _interopRequireDefault(require("./getQuery"));
+
+var _getMutation = _interopRequireDefault(require("./getMutation"));
+
+var _getSubscription = _interopRequireDefault(require("./getSubscription"));
+
+async function _default(options) {
+  global.resolvers = options.resolvers;
+  const query = await (0, _getQuery.default)(options);
+  const mutation = await (0, _getMutation.default)(options);
+  const subscription = await (0, _getSubscription.default)(options);
+  const schema = new _graphql.GraphQLSchema({
+    query,
+    mutation,
+    subscription
+  });
+  return schema;
+}

package/lib/errorHandler.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = errorHandler;
+
+var _app = require("@orion-js/app");
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function errorHandler(error, data) {
+  const {
+    logger
+  } = (0, _app.config)();
+  const message = `Error in resolver "${data.name}" ${data.model ? `of model "${data.model.name}"` : ''}`;
+
+  if (error && error.isOrionError) {
+    logger.warn(message, error);
+  } else {
+    const hash = _crypto.default.createHash('sha1').update(error.message, 'utf8').digest('hex').substring(0, 10);
+
+    error.hash = hash;
+    logger.error(message, error);
+    throw new _app.UserError('INTERNAL_SERVER_ERROR', 'Internal server error', {
+      hash
+    });
+  }
+}