@orion-js/graphql 3.4.10 → 3.4.12

package/lib/errorHandler.js

@@ -5,10 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = __importDefault(require("crypto"));
 const helpers_1 = require("@orion-js/helpers");
+const graphql_1 = require("graphql");
 function errorHandler(error, data) {
     const message = `Error in resolver "${data.name}" ${data.model ? `of model "${data.model.name}"` : ''}`;
     if (error && error.isOrionError) {
         console.warn(message, error);
+        throw new graphql_1.GraphQLError(error.message, {
+            originalError: error,
+            extensions: {
+                isOrionError: !!error.isOrionError,
+                isValidationError: !!error.isValidationError,
+                code: error.code,
+                info: error.getInfo()
+            }
+        });
     }
     else {
         const hash = crypto_1.default

package/lib/resolversSchemas/ResolverParams.js

@@ -28,7 +28,10 @@ exports.default = (0, models_1.createModel)({
         result: (0, resolvers_1.resolver)({
             returns: String,
             resolve: async function ({ resolver }) {
-                return resolver.returns.name;
+                const returns = (0, lodash_1.isArray)(resolver.returns) ? resolver.returns[0] : resolver.returns;
+                if (resolverReturnsIsModel(returns))
+                    return returns.name;
+                return;
             }
         }),
         basicResultQuery: (0, resolvers_1.resolver)({

package/lib/resolversSchemas/params.test.js

@@ -34,6 +34,32 @@ describe('Get params tests', () => {
         expect(result).toEqual(undefined);
         expect(basicResultQuery).toEqual('');
     });
+    it('Should return the correct information for a resolver that returns a string', async () => {
+        resolversStore_1.resolversStore.aaResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [String],
+            async resolve() {
+                return 'a';
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'aaResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('aaResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual(undefined);
+        expect(basicResultQuery).toEqual('');
+    });
     it('Should return the correct information for a resolver that returns a array of a model', async () => {
         const model = (0, models_1.createModel)({
             name: 'Item',
@@ -65,7 +91,7 @@ describe('Get params tests', () => {
         const basicResultQuery = await response.basicResultQuery();
         expect(response.name).toEqual('bResolver');
         expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
-        expect(result).toEqual(undefined);
+        expect(result).toEqual('Item');
         expect(basicResultQuery).toEqual('{ name }');
     });
     it('Should return the correct information for a resolver that returns a model', async () => {

package/lib/startGraphQL.test.js

@@ -19,6 +19,7 @@ const supertest_1 = __importDefault(require("supertest"));
 const typed_model_1 = require("@orion-js/typed-model");
 const cleanResolvers_1 = require("./cleanResolvers");
 const models_1 = require("@orion-js/models");
+const helpers_1 = require("@orion-js/helpers");
 describe('Test GraphQL Server', () => {
     beforeEach(() => {
         (0, cleanResolvers_1.cleanResolvers)();
@@ -108,6 +109,129 @@ describe('Test GraphQL Server', () => {
         expect(response.statusCode).toBe(400);
         expect(response.body.errors[0].message).toEqual('Cannot query field "helloWorld_doesntExists" on type "Query".');
     });
+    it('should return validation errors correctly', async () => {
+        const resolvers = {
+            helloWorld: (0, resolvers_1.resolver)({
+                params: {
+                    name: {
+                        type: 'string',
+                        validate: () => {
+                            return 'notUnique';
+                        }
+                    }
+                },
+                returns: 'string',
+                async resolve({ name }) {
+                    return `Hello ${name}`;
+                }
+            })
+        };
+        const app = (0, http_1.express)();
+        await (0, _1.startGraphQL)({
+            resolvers,
+            app
+        });
+        const response = await (0, supertest_1.default)(app)
+            .post('/graphql')
+            .send({
+            operationName: 'testOperation',
+            variables: {
+                name: 'Nico'
+            },
+            query: `query testOperation($name: String) {
+          helloWorld(name: $name)
+      }`
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toEqual({
+            errors: [
+                {
+                    message: 'Validation Error: {name: notUnique}',
+                    locations: [
+                        {
+                            line: 2,
+                            column: 11
+                        }
+                    ],
+                    path: ['helloWorld'],
+                    extensions: {
+                        isOrionError: true,
+                        isValidationError: true,
+                        code: 'validationError',
+                        info: {
+                            error: 'validationError',
+                            message: 'Validation Error',
+                            validationErrors: {
+                                name: 'notUnique'
+                            }
+                        }
+                    }
+                }
+            ],
+            data: {
+                helloWorld: null
+            }
+        });
+    });
+    it('should return user errors correctly', async () => {
+        const resolvers = {
+            helloWorld: (0, resolvers_1.resolver)({
+                params: {
+                    name: {
+                        type: 'string'
+                    }
+                },
+                returns: 'string',
+                async resolve({ name }) {
+                    throw new helpers_1.UserError('code', 'message');
+                    return `Hello ${name}`;
+                }
+            })
+        };
+        const app = (0, http_1.express)();
+        await (0, _1.startGraphQL)({
+            resolvers,
+            app
+        });
+        const response = await (0, supertest_1.default)(app)
+            .post('/graphql')
+            .send({
+            operationName: 'testOperation',
+            variables: {
+                name: 'Nico'
+            },
+            query: `query testOperation($name: String) {
+          helloWorld(name: $name)
+      }`
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toEqual({
+            errors: [
+                {
+                    message: 'message',
+                    locations: [
+                        {
+                            line: 2,
+                            column: 11
+                        }
+                    ],
+                    path: ['helloWorld'],
+                    extensions: {
+                        isOrionError: true,
+                        isValidationError: false,
+                        code: 'code',
+                        info: {
+                            error: 'code',
+                            message: 'message'
+                        }
+                    }
+                }
+            ],
+            data: {
+                helloWorld: null
+            }
+        });
+    });
     it('Should make requests to schemas with typed models', async () => {
         let Params = class Params {
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/graphql",
-  "version": "3.4.10",
+  "version": "3.4.12",
   "main": "lib/index.js",
   "author": "nicolaslopezj",
   "license": "MIT",
@@ -51,5 +51,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cb0152649af2360759c9aa65a1cd0435e82ef259"
+  "gitHead": "416d65a02a89193eb3e6d1bc97573ad6a949d378"
 }